1/*
2Copyright The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8    http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17// Code generated by protoc-gen-gogo. DO NOT EDIT.
18// source: k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto
19
20/*
21	Package v1beta1 is a generated protocol buffer package.
22
23	It is generated from these files:
24		k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto
25
26	It has these top-level messages:
27		AllowedCSIDriver
28		AllowedFlexVolume
29		AllowedHostPath
30		DaemonSet
31		DaemonSetCondition
32		DaemonSetList
33		DaemonSetSpec
34		DaemonSetStatus
35		DaemonSetUpdateStrategy
36		Deployment
37		DeploymentCondition
38		DeploymentList
39		DeploymentRollback
40		DeploymentSpec
41		DeploymentStatus
42		DeploymentStrategy
43		FSGroupStrategyOptions
44		HTTPIngressPath
45		HTTPIngressRuleValue
46		HostPortRange
47		IDRange
48		IPBlock
49		Ingress
50		IngressBackend
51		IngressList
52		IngressRule
53		IngressRuleValue
54		IngressSpec
55		IngressStatus
56		IngressTLS
57		NetworkPolicy
58		NetworkPolicyEgressRule
59		NetworkPolicyIngressRule
60		NetworkPolicyList
61		NetworkPolicyPeer
62		NetworkPolicyPort
63		NetworkPolicySpec
64		PodSecurityPolicy
65		PodSecurityPolicyList
66		PodSecurityPolicySpec
67		ReplicaSet
68		ReplicaSetCondition
69		ReplicaSetList
70		ReplicaSetSpec
71		ReplicaSetStatus
72		ReplicationControllerDummy
73		RollbackConfig
74		RollingUpdateDaemonSet
75		RollingUpdateDeployment
76		RunAsGroupStrategyOptions
77		RunAsUserStrategyOptions
78		RuntimeClassStrategyOptions
79		SELinuxStrategyOptions
80		Scale
81		ScaleSpec
82		ScaleStatus
83		SupplementalGroupsStrategyOptions
84*/
85package v1beta1
86
87import proto "github.com/gogo/protobuf/proto"
88import fmt "fmt"
89import math "math"
90
91import k8s_io_api_core_v1 "k8s.io/api/core/v1"
92import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
93
94import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
95
96import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
97
98import strings "strings"
99import reflect "reflect"
100
101import io "io"
102
103// Reference imports to suppress errors if they are not otherwise used.
104var _ = proto.Marshal
105var _ = fmt.Errorf
106var _ = math.Inf
107
108// This is a compile-time assertion to ensure that this generated file
109// is compatible with the proto package it is being compiled against.
110// A compilation error at this line likely means your copy of the
111// proto package needs to be updated.
112const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
113
114func (m *AllowedCSIDriver) Reset()                    { *m = AllowedCSIDriver{} }
115func (*AllowedCSIDriver) ProtoMessage()               {}
116func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
117
118func (m *AllowedFlexVolume) Reset()                    { *m = AllowedFlexVolume{} }
119func (*AllowedFlexVolume) ProtoMessage()               {}
120func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
121
122func (m *AllowedHostPath) Reset()                    { *m = AllowedHostPath{} }
123func (*AllowedHostPath) ProtoMessage()               {}
124func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
125
126func (m *DaemonSet) Reset()                    { *m = DaemonSet{} }
127func (*DaemonSet) ProtoMessage()               {}
128func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
129
130func (m *DaemonSetCondition) Reset()                    { *m = DaemonSetCondition{} }
131func (*DaemonSetCondition) ProtoMessage()               {}
132func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
133
134func (m *DaemonSetList) Reset()                    { *m = DaemonSetList{} }
135func (*DaemonSetList) ProtoMessage()               {}
136func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
137
138func (m *DaemonSetSpec) Reset()                    { *m = DaemonSetSpec{} }
139func (*DaemonSetSpec) ProtoMessage()               {}
140func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
141
142func (m *DaemonSetStatus) Reset()                    { *m = DaemonSetStatus{} }
143func (*DaemonSetStatus) ProtoMessage()               {}
144func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
145
146func (m *DaemonSetUpdateStrategy) Reset()                    { *m = DaemonSetUpdateStrategy{} }
147func (*DaemonSetUpdateStrategy) ProtoMessage()               {}
148func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
149
150func (m *Deployment) Reset()                    { *m = Deployment{} }
151func (*Deployment) ProtoMessage()               {}
152func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
153
154func (m *DeploymentCondition) Reset()                    { *m = DeploymentCondition{} }
155func (*DeploymentCondition) ProtoMessage()               {}
156func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
157
158func (m *DeploymentList) Reset()                    { *m = DeploymentList{} }
159func (*DeploymentList) ProtoMessage()               {}
160func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
161
162func (m *DeploymentRollback) Reset()                    { *m = DeploymentRollback{} }
163func (*DeploymentRollback) ProtoMessage()               {}
164func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
165
166func (m *DeploymentSpec) Reset()                    { *m = DeploymentSpec{} }
167func (*DeploymentSpec) ProtoMessage()               {}
168func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
169
170func (m *DeploymentStatus) Reset()                    { *m = DeploymentStatus{} }
171func (*DeploymentStatus) ProtoMessage()               {}
172func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
173
174func (m *DeploymentStrategy) Reset()                    { *m = DeploymentStrategy{} }
175func (*DeploymentStrategy) ProtoMessage()               {}
176func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
177
178func (m *FSGroupStrategyOptions) Reset()                    { *m = FSGroupStrategyOptions{} }
179func (*FSGroupStrategyOptions) ProtoMessage()               {}
180func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
181
182func (m *HTTPIngressPath) Reset()                    { *m = HTTPIngressPath{} }
183func (*HTTPIngressPath) ProtoMessage()               {}
184func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
185
186func (m *HTTPIngressRuleValue) Reset()                    { *m = HTTPIngressRuleValue{} }
187func (*HTTPIngressRuleValue) ProtoMessage()               {}
188func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
189
190func (m *HostPortRange) Reset()                    { *m = HostPortRange{} }
191func (*HostPortRange) ProtoMessage()               {}
192func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
193
194func (m *IDRange) Reset()                    { *m = IDRange{} }
195func (*IDRange) ProtoMessage()               {}
196func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
197
198func (m *IPBlock) Reset()                    { *m = IPBlock{} }
199func (*IPBlock) ProtoMessage()               {}
200func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
201
202func (m *Ingress) Reset()                    { *m = Ingress{} }
203func (*Ingress) ProtoMessage()               {}
204func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
205
206func (m *IngressBackend) Reset()                    { *m = IngressBackend{} }
207func (*IngressBackend) ProtoMessage()               {}
208func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
209
210func (m *IngressList) Reset()                    { *m = IngressList{} }
211func (*IngressList) ProtoMessage()               {}
212func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
213
214func (m *IngressRule) Reset()                    { *m = IngressRule{} }
215func (*IngressRule) ProtoMessage()               {}
216func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
217
218func (m *IngressRuleValue) Reset()                    { *m = IngressRuleValue{} }
219func (*IngressRuleValue) ProtoMessage()               {}
220func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
221
222func (m *IngressSpec) Reset()                    { *m = IngressSpec{} }
223func (*IngressSpec) ProtoMessage()               {}
224func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
225
226func (m *IngressStatus) Reset()                    { *m = IngressStatus{} }
227func (*IngressStatus) ProtoMessage()               {}
228func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
229
230func (m *IngressTLS) Reset()                    { *m = IngressTLS{} }
231func (*IngressTLS) ProtoMessage()               {}
232func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
233
234func (m *NetworkPolicy) Reset()                    { *m = NetworkPolicy{} }
235func (*NetworkPolicy) ProtoMessage()               {}
236func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
237
238func (m *NetworkPolicyEgressRule) Reset()      { *m = NetworkPolicyEgressRule{} }
239func (*NetworkPolicyEgressRule) ProtoMessage() {}
240func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) {
241	return fileDescriptorGenerated, []int{31}
242}
243
244func (m *NetworkPolicyIngressRule) Reset()      { *m = NetworkPolicyIngressRule{} }
245func (*NetworkPolicyIngressRule) ProtoMessage() {}
246func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) {
247	return fileDescriptorGenerated, []int{32}
248}
249
250func (m *NetworkPolicyList) Reset()                    { *m = NetworkPolicyList{} }
251func (*NetworkPolicyList) ProtoMessage()               {}
252func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
253
254func (m *NetworkPolicyPeer) Reset()                    { *m = NetworkPolicyPeer{} }
255func (*NetworkPolicyPeer) ProtoMessage()               {}
256func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
257
258func (m *NetworkPolicyPort) Reset()                    { *m = NetworkPolicyPort{} }
259func (*NetworkPolicyPort) ProtoMessage()               {}
260func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
261
262func (m *NetworkPolicySpec) Reset()                    { *m = NetworkPolicySpec{} }
263func (*NetworkPolicySpec) ProtoMessage()               {}
264func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
265
266func (m *PodSecurityPolicy) Reset()                    { *m = PodSecurityPolicy{} }
267func (*PodSecurityPolicy) ProtoMessage()               {}
268func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
269
270func (m *PodSecurityPolicyList) Reset()                    { *m = PodSecurityPolicyList{} }
271func (*PodSecurityPolicyList) ProtoMessage()               {}
272func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
273
274func (m *PodSecurityPolicySpec) Reset()                    { *m = PodSecurityPolicySpec{} }
275func (*PodSecurityPolicySpec) ProtoMessage()               {}
276func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} }
277
278func (m *ReplicaSet) Reset()                    { *m = ReplicaSet{} }
279func (*ReplicaSet) ProtoMessage()               {}
280func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} }
281
282func (m *ReplicaSetCondition) Reset()                    { *m = ReplicaSetCondition{} }
283func (*ReplicaSetCondition) ProtoMessage()               {}
284func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} }
285
286func (m *ReplicaSetList) Reset()                    { *m = ReplicaSetList{} }
287func (*ReplicaSetList) ProtoMessage()               {}
288func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} }
289
290func (m *ReplicaSetSpec) Reset()                    { *m = ReplicaSetSpec{} }
291func (*ReplicaSetSpec) ProtoMessage()               {}
292func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} }
293
294func (m *ReplicaSetStatus) Reset()                    { *m = ReplicaSetStatus{} }
295func (*ReplicaSetStatus) ProtoMessage()               {}
296func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} }
297
298func (m *ReplicationControllerDummy) Reset()      { *m = ReplicationControllerDummy{} }
299func (*ReplicationControllerDummy) ProtoMessage() {}
300func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) {
301	return fileDescriptorGenerated, []int{45}
302}
303
304func (m *RollbackConfig) Reset()                    { *m = RollbackConfig{} }
305func (*RollbackConfig) ProtoMessage()               {}
306func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} }
307
308func (m *RollingUpdateDaemonSet) Reset()                    { *m = RollingUpdateDaemonSet{} }
309func (*RollingUpdateDaemonSet) ProtoMessage()               {}
310func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{47} }
311
312func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
313func (*RollingUpdateDeployment) ProtoMessage() {}
314func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
315	return fileDescriptorGenerated, []int{48}
316}
317
318func (m *RunAsGroupStrategyOptions) Reset()      { *m = RunAsGroupStrategyOptions{} }
319func (*RunAsGroupStrategyOptions) ProtoMessage() {}
320func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) {
321	return fileDescriptorGenerated, []int{49}
322}
323
324func (m *RunAsUserStrategyOptions) Reset()      { *m = RunAsUserStrategyOptions{} }
325func (*RunAsUserStrategyOptions) ProtoMessage() {}
326func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
327	return fileDescriptorGenerated, []int{50}
328}
329
330func (m *RuntimeClassStrategyOptions) Reset()      { *m = RuntimeClassStrategyOptions{} }
331func (*RuntimeClassStrategyOptions) ProtoMessage() {}
332func (*RuntimeClassStrategyOptions) Descriptor() ([]byte, []int) {
333	return fileDescriptorGenerated, []int{51}
334}
335
336func (m *SELinuxStrategyOptions) Reset()                    { *m = SELinuxStrategyOptions{} }
337func (*SELinuxStrategyOptions) ProtoMessage()               {}
338func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} }
339
340func (m *Scale) Reset()                    { *m = Scale{} }
341func (*Scale) ProtoMessage()               {}
342func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} }
343
344func (m *ScaleSpec) Reset()                    { *m = ScaleSpec{} }
345func (*ScaleSpec) ProtoMessage()               {}
346func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{54} }
347
348func (m *ScaleStatus) Reset()                    { *m = ScaleStatus{} }
349func (*ScaleStatus) ProtoMessage()               {}
350func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{55} }
351
352func (m *SupplementalGroupsStrategyOptions) Reset()      { *m = SupplementalGroupsStrategyOptions{} }
353func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
354func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
355	return fileDescriptorGenerated, []int{56}
356}
357
358func init() {
359	proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver")
360	proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume")
361	proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath")
362	proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet")
363	proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition")
364	proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList")
365	proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec")
366	proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus")
367	proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy")
368	proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment")
369	proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition")
370	proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList")
371	proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback")
372	proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec")
373	proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus")
374	proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy")
375	proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions")
376	proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath")
377	proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue")
378	proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange")
379	proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange")
380	proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock")
381	proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress")
382	proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend")
383	proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList")
384	proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule")
385	proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue")
386	proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec")
387	proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus")
388	proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS")
389	proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy")
390	proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule")
391	proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule")
392	proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList")
393	proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer")
394	proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort")
395	proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec")
396	proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy")
397	proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList")
398	proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec")
399	proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet")
400	proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition")
401	proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList")
402	proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec")
403	proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus")
404	proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.api.extensions.v1beta1.ReplicationControllerDummy")
405	proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig")
406	proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet")
407	proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment")
408	proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions")
409	proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions")
410	proto.RegisterType((*RuntimeClassStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RuntimeClassStrategyOptions")
411	proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions")
412	proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale")
413	proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec")
414	proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus")
415	proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions")
416}
417func (m *AllowedCSIDriver) Marshal() (dAtA []byte, err error) {
418	size := m.Size()
419	dAtA = make([]byte, size)
420	n, err := m.MarshalTo(dAtA)
421	if err != nil {
422		return nil, err
423	}
424	return dAtA[:n], nil
425}
426
427func (m *AllowedCSIDriver) MarshalTo(dAtA []byte) (int, error) {
428	var i int
429	_ = i
430	var l int
431	_ = l
432	dAtA[i] = 0xa
433	i++
434	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
435	i += copy(dAtA[i:], m.Name)
436	return i, nil
437}
438
439func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) {
440	size := m.Size()
441	dAtA = make([]byte, size)
442	n, err := m.MarshalTo(dAtA)
443	if err != nil {
444		return nil, err
445	}
446	return dAtA[:n], nil
447}
448
449func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) {
450	var i int
451	_ = i
452	var l int
453	_ = l
454	dAtA[i] = 0xa
455	i++
456	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
457	i += copy(dAtA[i:], m.Driver)
458	return i, nil
459}
460
461func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) {
462	size := m.Size()
463	dAtA = make([]byte, size)
464	n, err := m.MarshalTo(dAtA)
465	if err != nil {
466		return nil, err
467	}
468	return dAtA[:n], nil
469}
470
471func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) {
472	var i int
473	_ = i
474	var l int
475	_ = l
476	dAtA[i] = 0xa
477	i++
478	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix)))
479	i += copy(dAtA[i:], m.PathPrefix)
480	dAtA[i] = 0x10
481	i++
482	if m.ReadOnly {
483		dAtA[i] = 1
484	} else {
485		dAtA[i] = 0
486	}
487	i++
488	return i, nil
489}
490
491func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
492	size := m.Size()
493	dAtA = make([]byte, size)
494	n, err := m.MarshalTo(dAtA)
495	if err != nil {
496		return nil, err
497	}
498	return dAtA[:n], nil
499}
500
501func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
502	var i int
503	_ = i
504	var l int
505	_ = l
506	dAtA[i] = 0xa
507	i++
508	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
509	n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
510	if err != nil {
511		return 0, err
512	}
513	i += n1
514	dAtA[i] = 0x12
515	i++
516	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
517	n2, err := m.Spec.MarshalTo(dAtA[i:])
518	if err != nil {
519		return 0, err
520	}
521	i += n2
522	dAtA[i] = 0x1a
523	i++
524	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
525	n3, err := m.Status.MarshalTo(dAtA[i:])
526	if err != nil {
527		return 0, err
528	}
529	i += n3
530	return i, nil
531}
532
533func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
534	size := m.Size()
535	dAtA = make([]byte, size)
536	n, err := m.MarshalTo(dAtA)
537	if err != nil {
538		return nil, err
539	}
540	return dAtA[:n], nil
541}
542
543func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
544	var i int
545	_ = i
546	var l int
547	_ = l
548	dAtA[i] = 0xa
549	i++
550	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
551	i += copy(dAtA[i:], m.Type)
552	dAtA[i] = 0x12
553	i++
554	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
555	i += copy(dAtA[i:], m.Status)
556	dAtA[i] = 0x1a
557	i++
558	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
559	n4, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
560	if err != nil {
561		return 0, err
562	}
563	i += n4
564	dAtA[i] = 0x22
565	i++
566	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
567	i += copy(dAtA[i:], m.Reason)
568	dAtA[i] = 0x2a
569	i++
570	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
571	i += copy(dAtA[i:], m.Message)
572	return i, nil
573}
574
575func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
576	size := m.Size()
577	dAtA = make([]byte, size)
578	n, err := m.MarshalTo(dAtA)
579	if err != nil {
580		return nil, err
581	}
582	return dAtA[:n], nil
583}
584
585func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
586	var i int
587	_ = i
588	var l int
589	_ = l
590	dAtA[i] = 0xa
591	i++
592	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
593	n5, err := m.ListMeta.MarshalTo(dAtA[i:])
594	if err != nil {
595		return 0, err
596	}
597	i += n5
598	if len(m.Items) > 0 {
599		for _, msg := range m.Items {
600			dAtA[i] = 0x12
601			i++
602			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
603			n, err := msg.MarshalTo(dAtA[i:])
604			if err != nil {
605				return 0, err
606			}
607			i += n
608		}
609	}
610	return i, nil
611}
612
613func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
614	size := m.Size()
615	dAtA = make([]byte, size)
616	n, err := m.MarshalTo(dAtA)
617	if err != nil {
618		return nil, err
619	}
620	return dAtA[:n], nil
621}
622
623func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
624	var i int
625	_ = i
626	var l int
627	_ = l
628	if m.Selector != nil {
629		dAtA[i] = 0xa
630		i++
631		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
632		n6, err := m.Selector.MarshalTo(dAtA[i:])
633		if err != nil {
634			return 0, err
635		}
636		i += n6
637	}
638	dAtA[i] = 0x12
639	i++
640	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
641	n7, err := m.Template.MarshalTo(dAtA[i:])
642	if err != nil {
643		return 0, err
644	}
645	i += n7
646	dAtA[i] = 0x1a
647	i++
648	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
649	n8, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
650	if err != nil {
651		return 0, err
652	}
653	i += n8
654	dAtA[i] = 0x20
655	i++
656	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
657	dAtA[i] = 0x28
658	i++
659	i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration))
660	if m.RevisionHistoryLimit != nil {
661		dAtA[i] = 0x30
662		i++
663		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
664	}
665	return i, nil
666}
667
668func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
669	size := m.Size()
670	dAtA = make([]byte, size)
671	n, err := m.MarshalTo(dAtA)
672	if err != nil {
673		return nil, err
674	}
675	return dAtA[:n], nil
676}
677
678func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
679	var i int
680	_ = i
681	var l int
682	_ = l
683	dAtA[i] = 0x8
684	i++
685	i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
686	dAtA[i] = 0x10
687	i++
688	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
689	dAtA[i] = 0x18
690	i++
691	i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
692	dAtA[i] = 0x20
693	i++
694	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
695	dAtA[i] = 0x28
696	i++
697	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
698	dAtA[i] = 0x30
699	i++
700	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
701	dAtA[i] = 0x38
702	i++
703	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
704	dAtA[i] = 0x40
705	i++
706	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
707	if m.CollisionCount != nil {
708		dAtA[i] = 0x48
709		i++
710		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
711	}
712	if len(m.Conditions) > 0 {
713		for _, msg := range m.Conditions {
714			dAtA[i] = 0x52
715			i++
716			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
717			n, err := msg.MarshalTo(dAtA[i:])
718			if err != nil {
719				return 0, err
720			}
721			i += n
722		}
723	}
724	return i, nil
725}
726
727func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
728	size := m.Size()
729	dAtA = make([]byte, size)
730	n, err := m.MarshalTo(dAtA)
731	if err != nil {
732		return nil, err
733	}
734	return dAtA[:n], nil
735}
736
737func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
738	var i int
739	_ = i
740	var l int
741	_ = l
742	dAtA[i] = 0xa
743	i++
744	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
745	i += copy(dAtA[i:], m.Type)
746	if m.RollingUpdate != nil {
747		dAtA[i] = 0x12
748		i++
749		i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
750		n9, err := m.RollingUpdate.MarshalTo(dAtA[i:])
751		if err != nil {
752			return 0, err
753		}
754		i += n9
755	}
756	return i, nil
757}
758
759func (m *Deployment) Marshal() (dAtA []byte, err error) {
760	size := m.Size()
761	dAtA = make([]byte, size)
762	n, err := m.MarshalTo(dAtA)
763	if err != nil {
764		return nil, err
765	}
766	return dAtA[:n], nil
767}
768
769func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
770	var i int
771	_ = i
772	var l int
773	_ = l
774	dAtA[i] = 0xa
775	i++
776	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
777	n10, err := m.ObjectMeta.MarshalTo(dAtA[i:])
778	if err != nil {
779		return 0, err
780	}
781	i += n10
782	dAtA[i] = 0x12
783	i++
784	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
785	n11, err := m.Spec.MarshalTo(dAtA[i:])
786	if err != nil {
787		return 0, err
788	}
789	i += n11
790	dAtA[i] = 0x1a
791	i++
792	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
793	n12, err := m.Status.MarshalTo(dAtA[i:])
794	if err != nil {
795		return 0, err
796	}
797	i += n12
798	return i, nil
799}
800
801func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
802	size := m.Size()
803	dAtA = make([]byte, size)
804	n, err := m.MarshalTo(dAtA)
805	if err != nil {
806		return nil, err
807	}
808	return dAtA[:n], nil
809}
810
811func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
812	var i int
813	_ = i
814	var l int
815	_ = l
816	dAtA[i] = 0xa
817	i++
818	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
819	i += copy(dAtA[i:], m.Type)
820	dAtA[i] = 0x12
821	i++
822	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
823	i += copy(dAtA[i:], m.Status)
824	dAtA[i] = 0x22
825	i++
826	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
827	i += copy(dAtA[i:], m.Reason)
828	dAtA[i] = 0x2a
829	i++
830	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
831	i += copy(dAtA[i:], m.Message)
832	dAtA[i] = 0x32
833	i++
834	i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
835	n13, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
836	if err != nil {
837		return 0, err
838	}
839	i += n13
840	dAtA[i] = 0x3a
841	i++
842	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
843	n14, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
844	if err != nil {
845		return 0, err
846	}
847	i += n14
848	return i, nil
849}
850
851func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
852	size := m.Size()
853	dAtA = make([]byte, size)
854	n, err := m.MarshalTo(dAtA)
855	if err != nil {
856		return nil, err
857	}
858	return dAtA[:n], nil
859}
860
861func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
862	var i int
863	_ = i
864	var l int
865	_ = l
866	dAtA[i] = 0xa
867	i++
868	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
869	n15, err := m.ListMeta.MarshalTo(dAtA[i:])
870	if err != nil {
871		return 0, err
872	}
873	i += n15
874	if len(m.Items) > 0 {
875		for _, msg := range m.Items {
876			dAtA[i] = 0x12
877			i++
878			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
879			n, err := msg.MarshalTo(dAtA[i:])
880			if err != nil {
881				return 0, err
882			}
883			i += n
884		}
885	}
886	return i, nil
887}
888
889func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
890	size := m.Size()
891	dAtA = make([]byte, size)
892	n, err := m.MarshalTo(dAtA)
893	if err != nil {
894		return nil, err
895	}
896	return dAtA[:n], nil
897}
898
899func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
900	var i int
901	_ = i
902	var l int
903	_ = l
904	dAtA[i] = 0xa
905	i++
906	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
907	i += copy(dAtA[i:], m.Name)
908	if len(m.UpdatedAnnotations) > 0 {
909		keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
910		for k := range m.UpdatedAnnotations {
911			keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
912		}
913		github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
914		for _, k := range keysForUpdatedAnnotations {
915			dAtA[i] = 0x12
916			i++
917			v := m.UpdatedAnnotations[string(k)]
918			mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
919			i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
920			dAtA[i] = 0xa
921			i++
922			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
923			i += copy(dAtA[i:], k)
924			dAtA[i] = 0x12
925			i++
926			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
927			i += copy(dAtA[i:], v)
928		}
929	}
930	dAtA[i] = 0x1a
931	i++
932	i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
933	n16, err := m.RollbackTo.MarshalTo(dAtA[i:])
934	if err != nil {
935		return 0, err
936	}
937	i += n16
938	return i, nil
939}
940
941func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
942	size := m.Size()
943	dAtA = make([]byte, size)
944	n, err := m.MarshalTo(dAtA)
945	if err != nil {
946		return nil, err
947	}
948	return dAtA[:n], nil
949}
950
951func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
952	var i int
953	_ = i
954	var l int
955	_ = l
956	if m.Replicas != nil {
957		dAtA[i] = 0x8
958		i++
959		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
960	}
961	if m.Selector != nil {
962		dAtA[i] = 0x12
963		i++
964		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
965		n17, err := m.Selector.MarshalTo(dAtA[i:])
966		if err != nil {
967			return 0, err
968		}
969		i += n17
970	}
971	dAtA[i] = 0x1a
972	i++
973	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
974	n18, err := m.Template.MarshalTo(dAtA[i:])
975	if err != nil {
976		return 0, err
977	}
978	i += n18
979	dAtA[i] = 0x22
980	i++
981	i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size()))
982	n19, err := m.Strategy.MarshalTo(dAtA[i:])
983	if err != nil {
984		return 0, err
985	}
986	i += n19
987	dAtA[i] = 0x28
988	i++
989	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
990	if m.RevisionHistoryLimit != nil {
991		dAtA[i] = 0x30
992		i++
993		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
994	}
995	dAtA[i] = 0x38
996	i++
997	if m.Paused {
998		dAtA[i] = 1
999	} else {
1000		dAtA[i] = 0
1001	}
1002	i++
1003	if m.RollbackTo != nil {
1004		dAtA[i] = 0x42
1005		i++
1006		i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
1007		n20, err := m.RollbackTo.MarshalTo(dAtA[i:])
1008		if err != nil {
1009			return 0, err
1010		}
1011		i += n20
1012	}
1013	if m.ProgressDeadlineSeconds != nil {
1014		dAtA[i] = 0x48
1015		i++
1016		i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
1017	}
1018	return i, nil
1019}
1020
1021func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
1022	size := m.Size()
1023	dAtA = make([]byte, size)
1024	n, err := m.MarshalTo(dAtA)
1025	if err != nil {
1026		return nil, err
1027	}
1028	return dAtA[:n], nil
1029}
1030
1031func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
1032	var i int
1033	_ = i
1034	var l int
1035	_ = l
1036	dAtA[i] = 0x8
1037	i++
1038	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1039	dAtA[i] = 0x10
1040	i++
1041	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1042	dAtA[i] = 0x18
1043	i++
1044	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1045	dAtA[i] = 0x20
1046	i++
1047	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1048	dAtA[i] = 0x28
1049	i++
1050	i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
1051	if len(m.Conditions) > 0 {
1052		for _, msg := range m.Conditions {
1053			dAtA[i] = 0x32
1054			i++
1055			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1056			n, err := msg.MarshalTo(dAtA[i:])
1057			if err != nil {
1058				return 0, err
1059			}
1060			i += n
1061		}
1062	}
1063	dAtA[i] = 0x38
1064	i++
1065	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1066	if m.CollisionCount != nil {
1067		dAtA[i] = 0x40
1068		i++
1069		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1070	}
1071	return i, nil
1072}
1073
1074func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
1075	size := m.Size()
1076	dAtA = make([]byte, size)
1077	n, err := m.MarshalTo(dAtA)
1078	if err != nil {
1079		return nil, err
1080	}
1081	return dAtA[:n], nil
1082}
1083
1084func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
1085	var i int
1086	_ = i
1087	var l int
1088	_ = l
1089	dAtA[i] = 0xa
1090	i++
1091	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1092	i += copy(dAtA[i:], m.Type)
1093	if m.RollingUpdate != nil {
1094		dAtA[i] = 0x12
1095		i++
1096		i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
1097		n21, err := m.RollingUpdate.MarshalTo(dAtA[i:])
1098		if err != nil {
1099			return 0, err
1100		}
1101		i += n21
1102	}
1103	return i, nil
1104}
1105
1106func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
1107	size := m.Size()
1108	dAtA = make([]byte, size)
1109	n, err := m.MarshalTo(dAtA)
1110	if err != nil {
1111		return nil, err
1112	}
1113	return dAtA[:n], nil
1114}
1115
1116func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1117	var i int
1118	_ = i
1119	var l int
1120	_ = l
1121	dAtA[i] = 0xa
1122	i++
1123	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
1124	i += copy(dAtA[i:], m.Rule)
1125	if len(m.Ranges) > 0 {
1126		for _, msg := range m.Ranges {
1127			dAtA[i] = 0x12
1128			i++
1129			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1130			n, err := msg.MarshalTo(dAtA[i:])
1131			if err != nil {
1132				return 0, err
1133			}
1134			i += n
1135		}
1136	}
1137	return i, nil
1138}
1139
1140func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) {
1141	size := m.Size()
1142	dAtA = make([]byte, size)
1143	n, err := m.MarshalTo(dAtA)
1144	if err != nil {
1145		return nil, err
1146	}
1147	return dAtA[:n], nil
1148}
1149
1150func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) {
1151	var i int
1152	_ = i
1153	var l int
1154	_ = l
1155	dAtA[i] = 0xa
1156	i++
1157	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
1158	i += copy(dAtA[i:], m.Path)
1159	dAtA[i] = 0x12
1160	i++
1161	i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1162	n22, err := m.Backend.MarshalTo(dAtA[i:])
1163	if err != nil {
1164		return 0, err
1165	}
1166	i += n22
1167	return i, nil
1168}
1169
1170func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) {
1171	size := m.Size()
1172	dAtA = make([]byte, size)
1173	n, err := m.MarshalTo(dAtA)
1174	if err != nil {
1175		return nil, err
1176	}
1177	return dAtA[:n], nil
1178}
1179
1180func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1181	var i int
1182	_ = i
1183	var l int
1184	_ = l
1185	if len(m.Paths) > 0 {
1186		for _, msg := range m.Paths {
1187			dAtA[i] = 0xa
1188			i++
1189			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1190			n, err := msg.MarshalTo(dAtA[i:])
1191			if err != nil {
1192				return 0, err
1193			}
1194			i += n
1195		}
1196	}
1197	return i, nil
1198}
1199
1200func (m *HostPortRange) Marshal() (dAtA []byte, err error) {
1201	size := m.Size()
1202	dAtA = make([]byte, size)
1203	n, err := m.MarshalTo(dAtA)
1204	if err != nil {
1205		return nil, err
1206	}
1207	return dAtA[:n], nil
1208}
1209
1210func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) {
1211	var i int
1212	_ = i
1213	var l int
1214	_ = l
1215	dAtA[i] = 0x8
1216	i++
1217	i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1218	dAtA[i] = 0x10
1219	i++
1220	i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1221	return i, nil
1222}
1223
1224func (m *IDRange) Marshal() (dAtA []byte, err error) {
1225	size := m.Size()
1226	dAtA = make([]byte, size)
1227	n, err := m.MarshalTo(dAtA)
1228	if err != nil {
1229		return nil, err
1230	}
1231	return dAtA[:n], nil
1232}
1233
1234func (m *IDRange) MarshalTo(dAtA []byte) (int, error) {
1235	var i int
1236	_ = i
1237	var l int
1238	_ = l
1239	dAtA[i] = 0x8
1240	i++
1241	i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1242	dAtA[i] = 0x10
1243	i++
1244	i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1245	return i, nil
1246}
1247
1248func (m *IPBlock) Marshal() (dAtA []byte, err error) {
1249	size := m.Size()
1250	dAtA = make([]byte, size)
1251	n, err := m.MarshalTo(dAtA)
1252	if err != nil {
1253		return nil, err
1254	}
1255	return dAtA[:n], nil
1256}
1257
1258func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) {
1259	var i int
1260	_ = i
1261	var l int
1262	_ = l
1263	dAtA[i] = 0xa
1264	i++
1265	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR)))
1266	i += copy(dAtA[i:], m.CIDR)
1267	if len(m.Except) > 0 {
1268		for _, s := range m.Except {
1269			dAtA[i] = 0x12
1270			i++
1271			l = len(s)
1272			for l >= 1<<7 {
1273				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1274				l >>= 7
1275				i++
1276			}
1277			dAtA[i] = uint8(l)
1278			i++
1279			i += copy(dAtA[i:], s)
1280		}
1281	}
1282	return i, nil
1283}
1284
1285func (m *Ingress) Marshal() (dAtA []byte, err error) {
1286	size := m.Size()
1287	dAtA = make([]byte, size)
1288	n, err := m.MarshalTo(dAtA)
1289	if err != nil {
1290		return nil, err
1291	}
1292	return dAtA[:n], nil
1293}
1294
1295func (m *Ingress) MarshalTo(dAtA []byte) (int, error) {
1296	var i int
1297	_ = i
1298	var l int
1299	_ = l
1300	dAtA[i] = 0xa
1301	i++
1302	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1303	n23, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1304	if err != nil {
1305		return 0, err
1306	}
1307	i += n23
1308	dAtA[i] = 0x12
1309	i++
1310	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1311	n24, err := m.Spec.MarshalTo(dAtA[i:])
1312	if err != nil {
1313		return 0, err
1314	}
1315	i += n24
1316	dAtA[i] = 0x1a
1317	i++
1318	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
1319	n25, err := m.Status.MarshalTo(dAtA[i:])
1320	if err != nil {
1321		return 0, err
1322	}
1323	i += n25
1324	return i, nil
1325}
1326
1327func (m *IngressBackend) Marshal() (dAtA []byte, err error) {
1328	size := m.Size()
1329	dAtA = make([]byte, size)
1330	n, err := m.MarshalTo(dAtA)
1331	if err != nil {
1332		return nil, err
1333	}
1334	return dAtA[:n], nil
1335}
1336
1337func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) {
1338	var i int
1339	_ = i
1340	var l int
1341	_ = l
1342	dAtA[i] = 0xa
1343	i++
1344	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
1345	i += copy(dAtA[i:], m.ServiceName)
1346	dAtA[i] = 0x12
1347	i++
1348	i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort.Size()))
1349	n26, err := m.ServicePort.MarshalTo(dAtA[i:])
1350	if err != nil {
1351		return 0, err
1352	}
1353	i += n26
1354	return i, nil
1355}
1356
1357func (m *IngressList) Marshal() (dAtA []byte, err error) {
1358	size := m.Size()
1359	dAtA = make([]byte, size)
1360	n, err := m.MarshalTo(dAtA)
1361	if err != nil {
1362		return nil, err
1363	}
1364	return dAtA[:n], nil
1365}
1366
1367func (m *IngressList) MarshalTo(dAtA []byte) (int, error) {
1368	var i int
1369	_ = i
1370	var l int
1371	_ = l
1372	dAtA[i] = 0xa
1373	i++
1374	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1375	n27, err := m.ListMeta.MarshalTo(dAtA[i:])
1376	if err != nil {
1377		return 0, err
1378	}
1379	i += n27
1380	if len(m.Items) > 0 {
1381		for _, msg := range m.Items {
1382			dAtA[i] = 0x12
1383			i++
1384			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1385			n, err := msg.MarshalTo(dAtA[i:])
1386			if err != nil {
1387				return 0, err
1388			}
1389			i += n
1390		}
1391	}
1392	return i, nil
1393}
1394
1395func (m *IngressRule) Marshal() (dAtA []byte, err error) {
1396	size := m.Size()
1397	dAtA = make([]byte, size)
1398	n, err := m.MarshalTo(dAtA)
1399	if err != nil {
1400		return nil, err
1401	}
1402	return dAtA[:n], nil
1403}
1404
1405func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) {
1406	var i int
1407	_ = i
1408	var l int
1409	_ = l
1410	dAtA[i] = 0xa
1411	i++
1412	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
1413	i += copy(dAtA[i:], m.Host)
1414	dAtA[i] = 0x12
1415	i++
1416	i = encodeVarintGenerated(dAtA, i, uint64(m.IngressRuleValue.Size()))
1417	n28, err := m.IngressRuleValue.MarshalTo(dAtA[i:])
1418	if err != nil {
1419		return 0, err
1420	}
1421	i += n28
1422	return i, nil
1423}
1424
1425func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) {
1426	size := m.Size()
1427	dAtA = make([]byte, size)
1428	n, err := m.MarshalTo(dAtA)
1429	if err != nil {
1430		return nil, err
1431	}
1432	return dAtA[:n], nil
1433}
1434
1435func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1436	var i int
1437	_ = i
1438	var l int
1439	_ = l
1440	if m.HTTP != nil {
1441		dAtA[i] = 0xa
1442		i++
1443		i = encodeVarintGenerated(dAtA, i, uint64(m.HTTP.Size()))
1444		n29, err := m.HTTP.MarshalTo(dAtA[i:])
1445		if err != nil {
1446			return 0, err
1447		}
1448		i += n29
1449	}
1450	return i, nil
1451}
1452
1453func (m *IngressSpec) Marshal() (dAtA []byte, err error) {
1454	size := m.Size()
1455	dAtA = make([]byte, size)
1456	n, err := m.MarshalTo(dAtA)
1457	if err != nil {
1458		return nil, err
1459	}
1460	return dAtA[:n], nil
1461}
1462
1463func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) {
1464	var i int
1465	_ = i
1466	var l int
1467	_ = l
1468	if m.Backend != nil {
1469		dAtA[i] = 0xa
1470		i++
1471		i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1472		n30, err := m.Backend.MarshalTo(dAtA[i:])
1473		if err != nil {
1474			return 0, err
1475		}
1476		i += n30
1477	}
1478	if len(m.TLS) > 0 {
1479		for _, msg := range m.TLS {
1480			dAtA[i] = 0x12
1481			i++
1482			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1483			n, err := msg.MarshalTo(dAtA[i:])
1484			if err != nil {
1485				return 0, err
1486			}
1487			i += n
1488		}
1489	}
1490	if len(m.Rules) > 0 {
1491		for _, msg := range m.Rules {
1492			dAtA[i] = 0x1a
1493			i++
1494			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1495			n, err := msg.MarshalTo(dAtA[i:])
1496			if err != nil {
1497				return 0, err
1498			}
1499			i += n
1500		}
1501	}
1502	return i, nil
1503}
1504
1505func (m *IngressStatus) Marshal() (dAtA []byte, err error) {
1506	size := m.Size()
1507	dAtA = make([]byte, size)
1508	n, err := m.MarshalTo(dAtA)
1509	if err != nil {
1510		return nil, err
1511	}
1512	return dAtA[:n], nil
1513}
1514
1515func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) {
1516	var i int
1517	_ = i
1518	var l int
1519	_ = l
1520	dAtA[i] = 0xa
1521	i++
1522	i = encodeVarintGenerated(dAtA, i, uint64(m.LoadBalancer.Size()))
1523	n31, err := m.LoadBalancer.MarshalTo(dAtA[i:])
1524	if err != nil {
1525		return 0, err
1526	}
1527	i += n31
1528	return i, nil
1529}
1530
1531func (m *IngressTLS) Marshal() (dAtA []byte, err error) {
1532	size := m.Size()
1533	dAtA = make([]byte, size)
1534	n, err := m.MarshalTo(dAtA)
1535	if err != nil {
1536		return nil, err
1537	}
1538	return dAtA[:n], nil
1539}
1540
1541func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) {
1542	var i int
1543	_ = i
1544	var l int
1545	_ = l
1546	if len(m.Hosts) > 0 {
1547		for _, s := range m.Hosts {
1548			dAtA[i] = 0xa
1549			i++
1550			l = len(s)
1551			for l >= 1<<7 {
1552				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1553				l >>= 7
1554				i++
1555			}
1556			dAtA[i] = uint8(l)
1557			i++
1558			i += copy(dAtA[i:], s)
1559		}
1560	}
1561	dAtA[i] = 0x12
1562	i++
1563	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName)))
1564	i += copy(dAtA[i:], m.SecretName)
1565	return i, nil
1566}
1567
1568func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) {
1569	size := m.Size()
1570	dAtA = make([]byte, size)
1571	n, err := m.MarshalTo(dAtA)
1572	if err != nil {
1573		return nil, err
1574	}
1575	return dAtA[:n], nil
1576}
1577
1578func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) {
1579	var i int
1580	_ = i
1581	var l int
1582	_ = l
1583	dAtA[i] = 0xa
1584	i++
1585	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1586	n32, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1587	if err != nil {
1588		return 0, err
1589	}
1590	i += n32
1591	dAtA[i] = 0x12
1592	i++
1593	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1594	n33, err := m.Spec.MarshalTo(dAtA[i:])
1595	if err != nil {
1596		return 0, err
1597	}
1598	i += n33
1599	return i, nil
1600}
1601
1602func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) {
1603	size := m.Size()
1604	dAtA = make([]byte, size)
1605	n, err := m.MarshalTo(dAtA)
1606	if err != nil {
1607		return nil, err
1608	}
1609	return dAtA[:n], nil
1610}
1611
1612func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) {
1613	var i int
1614	_ = i
1615	var l int
1616	_ = l
1617	if len(m.Ports) > 0 {
1618		for _, msg := range m.Ports {
1619			dAtA[i] = 0xa
1620			i++
1621			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1622			n, err := msg.MarshalTo(dAtA[i:])
1623			if err != nil {
1624				return 0, err
1625			}
1626			i += n
1627		}
1628	}
1629	if len(m.To) > 0 {
1630		for _, msg := range m.To {
1631			dAtA[i] = 0x12
1632			i++
1633			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1634			n, err := msg.MarshalTo(dAtA[i:])
1635			if err != nil {
1636				return 0, err
1637			}
1638			i += n
1639		}
1640	}
1641	return i, nil
1642}
1643
1644func (m *NetworkPolicyIngressRule) Marshal() (dAtA []byte, err error) {
1645	size := m.Size()
1646	dAtA = make([]byte, size)
1647	n, err := m.MarshalTo(dAtA)
1648	if err != nil {
1649		return nil, err
1650	}
1651	return dAtA[:n], nil
1652}
1653
1654func (m *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) {
1655	var i int
1656	_ = i
1657	var l int
1658	_ = l
1659	if len(m.Ports) > 0 {
1660		for _, msg := range m.Ports {
1661			dAtA[i] = 0xa
1662			i++
1663			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1664			n, err := msg.MarshalTo(dAtA[i:])
1665			if err != nil {
1666				return 0, err
1667			}
1668			i += n
1669		}
1670	}
1671	if len(m.From) > 0 {
1672		for _, msg := range m.From {
1673			dAtA[i] = 0x12
1674			i++
1675			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1676			n, err := msg.MarshalTo(dAtA[i:])
1677			if err != nil {
1678				return 0, err
1679			}
1680			i += n
1681		}
1682	}
1683	return i, nil
1684}
1685
1686func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) {
1687	size := m.Size()
1688	dAtA = make([]byte, size)
1689	n, err := m.MarshalTo(dAtA)
1690	if err != nil {
1691		return nil, err
1692	}
1693	return dAtA[:n], nil
1694}
1695
1696func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) {
1697	var i int
1698	_ = i
1699	var l int
1700	_ = l
1701	dAtA[i] = 0xa
1702	i++
1703	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1704	n34, err := m.ListMeta.MarshalTo(dAtA[i:])
1705	if err != nil {
1706		return 0, err
1707	}
1708	i += n34
1709	if len(m.Items) > 0 {
1710		for _, msg := range m.Items {
1711			dAtA[i] = 0x12
1712			i++
1713			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1714			n, err := msg.MarshalTo(dAtA[i:])
1715			if err != nil {
1716				return 0, err
1717			}
1718			i += n
1719		}
1720	}
1721	return i, nil
1722}
1723
1724func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) {
1725	size := m.Size()
1726	dAtA = make([]byte, size)
1727	n, err := m.MarshalTo(dAtA)
1728	if err != nil {
1729		return nil, err
1730	}
1731	return dAtA[:n], nil
1732}
1733
1734func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) {
1735	var i int
1736	_ = i
1737	var l int
1738	_ = l
1739	if m.PodSelector != nil {
1740		dAtA[i] = 0xa
1741		i++
1742		i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1743		n35, err := m.PodSelector.MarshalTo(dAtA[i:])
1744		if err != nil {
1745			return 0, err
1746		}
1747		i += n35
1748	}
1749	if m.NamespaceSelector != nil {
1750		dAtA[i] = 0x12
1751		i++
1752		i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
1753		n36, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
1754		if err != nil {
1755			return 0, err
1756		}
1757		i += n36
1758	}
1759	if m.IPBlock != nil {
1760		dAtA[i] = 0x1a
1761		i++
1762		i = encodeVarintGenerated(dAtA, i, uint64(m.IPBlock.Size()))
1763		n37, err := m.IPBlock.MarshalTo(dAtA[i:])
1764		if err != nil {
1765			return 0, err
1766		}
1767		i += n37
1768	}
1769	return i, nil
1770}
1771
1772func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) {
1773	size := m.Size()
1774	dAtA = make([]byte, size)
1775	n, err := m.MarshalTo(dAtA)
1776	if err != nil {
1777		return nil, err
1778	}
1779	return dAtA[:n], nil
1780}
1781
1782func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) {
1783	var i int
1784	_ = i
1785	var l int
1786	_ = l
1787	if m.Protocol != nil {
1788		dAtA[i] = 0xa
1789		i++
1790		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol)))
1791		i += copy(dAtA[i:], *m.Protocol)
1792	}
1793	if m.Port != nil {
1794		dAtA[i] = 0x12
1795		i++
1796		i = encodeVarintGenerated(dAtA, i, uint64(m.Port.Size()))
1797		n38, err := m.Port.MarshalTo(dAtA[i:])
1798		if err != nil {
1799			return 0, err
1800		}
1801		i += n38
1802	}
1803	return i, nil
1804}
1805
1806func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) {
1807	size := m.Size()
1808	dAtA = make([]byte, size)
1809	n, err := m.MarshalTo(dAtA)
1810	if err != nil {
1811		return nil, err
1812	}
1813	return dAtA[:n], nil
1814}
1815
1816func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1817	var i int
1818	_ = i
1819	var l int
1820	_ = l
1821	dAtA[i] = 0xa
1822	i++
1823	i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1824	n39, err := m.PodSelector.MarshalTo(dAtA[i:])
1825	if err != nil {
1826		return 0, err
1827	}
1828	i += n39
1829	if len(m.Ingress) > 0 {
1830		for _, msg := range m.Ingress {
1831			dAtA[i] = 0x12
1832			i++
1833			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1834			n, err := msg.MarshalTo(dAtA[i:])
1835			if err != nil {
1836				return 0, err
1837			}
1838			i += n
1839		}
1840	}
1841	if len(m.Egress) > 0 {
1842		for _, msg := range m.Egress {
1843			dAtA[i] = 0x1a
1844			i++
1845			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1846			n, err := msg.MarshalTo(dAtA[i:])
1847			if err != nil {
1848				return 0, err
1849			}
1850			i += n
1851		}
1852	}
1853	if len(m.PolicyTypes) > 0 {
1854		for _, s := range m.PolicyTypes {
1855			dAtA[i] = 0x22
1856			i++
1857			l = len(s)
1858			for l >= 1<<7 {
1859				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1860				l >>= 7
1861				i++
1862			}
1863			dAtA[i] = uint8(l)
1864			i++
1865			i += copy(dAtA[i:], s)
1866		}
1867	}
1868	return i, nil
1869}
1870
1871func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) {
1872	size := m.Size()
1873	dAtA = make([]byte, size)
1874	n, err := m.MarshalTo(dAtA)
1875	if err != nil {
1876		return nil, err
1877	}
1878	return dAtA[:n], nil
1879}
1880
1881func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) {
1882	var i int
1883	_ = i
1884	var l int
1885	_ = l
1886	dAtA[i] = 0xa
1887	i++
1888	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1889	n40, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1890	if err != nil {
1891		return 0, err
1892	}
1893	i += n40
1894	dAtA[i] = 0x12
1895	i++
1896	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1897	n41, err := m.Spec.MarshalTo(dAtA[i:])
1898	if err != nil {
1899		return 0, err
1900	}
1901	i += n41
1902	return i, nil
1903}
1904
1905func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) {
1906	size := m.Size()
1907	dAtA = make([]byte, size)
1908	n, err := m.MarshalTo(dAtA)
1909	if err != nil {
1910		return nil, err
1911	}
1912	return dAtA[:n], nil
1913}
1914
1915func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) {
1916	var i int
1917	_ = i
1918	var l int
1919	_ = l
1920	dAtA[i] = 0xa
1921	i++
1922	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1923	n42, err := m.ListMeta.MarshalTo(dAtA[i:])
1924	if err != nil {
1925		return 0, err
1926	}
1927	i += n42
1928	if len(m.Items) > 0 {
1929		for _, msg := range m.Items {
1930			dAtA[i] = 0x12
1931			i++
1932			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1933			n, err := msg.MarshalTo(dAtA[i:])
1934			if err != nil {
1935				return 0, err
1936			}
1937			i += n
1938		}
1939	}
1940	return i, nil
1941}
1942
1943func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) {
1944	size := m.Size()
1945	dAtA = make([]byte, size)
1946	n, err := m.MarshalTo(dAtA)
1947	if err != nil {
1948		return nil, err
1949	}
1950	return dAtA[:n], nil
1951}
1952
1953func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1954	var i int
1955	_ = i
1956	var l int
1957	_ = l
1958	dAtA[i] = 0x8
1959	i++
1960	if m.Privileged {
1961		dAtA[i] = 1
1962	} else {
1963		dAtA[i] = 0
1964	}
1965	i++
1966	if len(m.DefaultAddCapabilities) > 0 {
1967		for _, s := range m.DefaultAddCapabilities {
1968			dAtA[i] = 0x12
1969			i++
1970			l = len(s)
1971			for l >= 1<<7 {
1972				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1973				l >>= 7
1974				i++
1975			}
1976			dAtA[i] = uint8(l)
1977			i++
1978			i += copy(dAtA[i:], s)
1979		}
1980	}
1981	if len(m.RequiredDropCapabilities) > 0 {
1982		for _, s := range m.RequiredDropCapabilities {
1983			dAtA[i] = 0x1a
1984			i++
1985			l = len(s)
1986			for l >= 1<<7 {
1987				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1988				l >>= 7
1989				i++
1990			}
1991			dAtA[i] = uint8(l)
1992			i++
1993			i += copy(dAtA[i:], s)
1994		}
1995	}
1996	if len(m.AllowedCapabilities) > 0 {
1997		for _, s := range m.AllowedCapabilities {
1998			dAtA[i] = 0x22
1999			i++
2000			l = len(s)
2001			for l >= 1<<7 {
2002				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2003				l >>= 7
2004				i++
2005			}
2006			dAtA[i] = uint8(l)
2007			i++
2008			i += copy(dAtA[i:], s)
2009		}
2010	}
2011	if len(m.Volumes) > 0 {
2012		for _, s := range m.Volumes {
2013			dAtA[i] = 0x2a
2014			i++
2015			l = len(s)
2016			for l >= 1<<7 {
2017				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2018				l >>= 7
2019				i++
2020			}
2021			dAtA[i] = uint8(l)
2022			i++
2023			i += copy(dAtA[i:], s)
2024		}
2025	}
2026	dAtA[i] = 0x30
2027	i++
2028	if m.HostNetwork {
2029		dAtA[i] = 1
2030	} else {
2031		dAtA[i] = 0
2032	}
2033	i++
2034	if len(m.HostPorts) > 0 {
2035		for _, msg := range m.HostPorts {
2036			dAtA[i] = 0x3a
2037			i++
2038			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2039			n, err := msg.MarshalTo(dAtA[i:])
2040			if err != nil {
2041				return 0, err
2042			}
2043			i += n
2044		}
2045	}
2046	dAtA[i] = 0x40
2047	i++
2048	if m.HostPID {
2049		dAtA[i] = 1
2050	} else {
2051		dAtA[i] = 0
2052	}
2053	i++
2054	dAtA[i] = 0x48
2055	i++
2056	if m.HostIPC {
2057		dAtA[i] = 1
2058	} else {
2059		dAtA[i] = 0
2060	}
2061	i++
2062	dAtA[i] = 0x52
2063	i++
2064	i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size()))
2065	n43, err := m.SELinux.MarshalTo(dAtA[i:])
2066	if err != nil {
2067		return 0, err
2068	}
2069	i += n43
2070	dAtA[i] = 0x5a
2071	i++
2072	i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size()))
2073	n44, err := m.RunAsUser.MarshalTo(dAtA[i:])
2074	if err != nil {
2075		return 0, err
2076	}
2077	i += n44
2078	dAtA[i] = 0x62
2079	i++
2080	i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size()))
2081	n45, err := m.SupplementalGroups.MarshalTo(dAtA[i:])
2082	if err != nil {
2083		return 0, err
2084	}
2085	i += n45
2086	dAtA[i] = 0x6a
2087	i++
2088	i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size()))
2089	n46, err := m.FSGroup.MarshalTo(dAtA[i:])
2090	if err != nil {
2091		return 0, err
2092	}
2093	i += n46
2094	dAtA[i] = 0x70
2095	i++
2096	if m.ReadOnlyRootFilesystem {
2097		dAtA[i] = 1
2098	} else {
2099		dAtA[i] = 0
2100	}
2101	i++
2102	if m.DefaultAllowPrivilegeEscalation != nil {
2103		dAtA[i] = 0x78
2104		i++
2105		if *m.DefaultAllowPrivilegeEscalation {
2106			dAtA[i] = 1
2107		} else {
2108			dAtA[i] = 0
2109		}
2110		i++
2111	}
2112	if m.AllowPrivilegeEscalation != nil {
2113		dAtA[i] = 0x80
2114		i++
2115		dAtA[i] = 0x1
2116		i++
2117		if *m.AllowPrivilegeEscalation {
2118			dAtA[i] = 1
2119		} else {
2120			dAtA[i] = 0
2121		}
2122		i++
2123	}
2124	if len(m.AllowedHostPaths) > 0 {
2125		for _, msg := range m.AllowedHostPaths {
2126			dAtA[i] = 0x8a
2127			i++
2128			dAtA[i] = 0x1
2129			i++
2130			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2131			n, err := msg.MarshalTo(dAtA[i:])
2132			if err != nil {
2133				return 0, err
2134			}
2135			i += n
2136		}
2137	}
2138	if len(m.AllowedFlexVolumes) > 0 {
2139		for _, msg := range m.AllowedFlexVolumes {
2140			dAtA[i] = 0x92
2141			i++
2142			dAtA[i] = 0x1
2143			i++
2144			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2145			n, err := msg.MarshalTo(dAtA[i:])
2146			if err != nil {
2147				return 0, err
2148			}
2149			i += n
2150		}
2151	}
2152	if len(m.AllowedUnsafeSysctls) > 0 {
2153		for _, s := range m.AllowedUnsafeSysctls {
2154			dAtA[i] = 0x9a
2155			i++
2156			dAtA[i] = 0x1
2157			i++
2158			l = len(s)
2159			for l >= 1<<7 {
2160				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2161				l >>= 7
2162				i++
2163			}
2164			dAtA[i] = uint8(l)
2165			i++
2166			i += copy(dAtA[i:], s)
2167		}
2168	}
2169	if len(m.ForbiddenSysctls) > 0 {
2170		for _, s := range m.ForbiddenSysctls {
2171			dAtA[i] = 0xa2
2172			i++
2173			dAtA[i] = 0x1
2174			i++
2175			l = len(s)
2176			for l >= 1<<7 {
2177				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2178				l >>= 7
2179				i++
2180			}
2181			dAtA[i] = uint8(l)
2182			i++
2183			i += copy(dAtA[i:], s)
2184		}
2185	}
2186	if len(m.AllowedProcMountTypes) > 0 {
2187		for _, s := range m.AllowedProcMountTypes {
2188			dAtA[i] = 0xaa
2189			i++
2190			dAtA[i] = 0x1
2191			i++
2192			l = len(s)
2193			for l >= 1<<7 {
2194				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2195				l >>= 7
2196				i++
2197			}
2198			dAtA[i] = uint8(l)
2199			i++
2200			i += copy(dAtA[i:], s)
2201		}
2202	}
2203	if m.RunAsGroup != nil {
2204		dAtA[i] = 0xb2
2205		i++
2206		dAtA[i] = 0x1
2207		i++
2208		i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size()))
2209		n47, err := m.RunAsGroup.MarshalTo(dAtA[i:])
2210		if err != nil {
2211			return 0, err
2212		}
2213		i += n47
2214	}
2215	if len(m.AllowedCSIDrivers) > 0 {
2216		for _, msg := range m.AllowedCSIDrivers {
2217			dAtA[i] = 0xba
2218			i++
2219			dAtA[i] = 0x1
2220			i++
2221			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2222			n, err := msg.MarshalTo(dAtA[i:])
2223			if err != nil {
2224				return 0, err
2225			}
2226			i += n
2227		}
2228	}
2229	if m.RuntimeClass != nil {
2230		dAtA[i] = 0xc2
2231		i++
2232		dAtA[i] = 0x1
2233		i++
2234		i = encodeVarintGenerated(dAtA, i, uint64(m.RuntimeClass.Size()))
2235		n48, err := m.RuntimeClass.MarshalTo(dAtA[i:])
2236		if err != nil {
2237			return 0, err
2238		}
2239		i += n48
2240	}
2241	return i, nil
2242}
2243
2244func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
2245	size := m.Size()
2246	dAtA = make([]byte, size)
2247	n, err := m.MarshalTo(dAtA)
2248	if err != nil {
2249		return nil, err
2250	}
2251	return dAtA[:n], nil
2252}
2253
2254func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
2255	var i int
2256	_ = i
2257	var l int
2258	_ = l
2259	dAtA[i] = 0xa
2260	i++
2261	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2262	n49, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2263	if err != nil {
2264		return 0, err
2265	}
2266	i += n49
2267	dAtA[i] = 0x12
2268	i++
2269	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2270	n50, err := m.Spec.MarshalTo(dAtA[i:])
2271	if err != nil {
2272		return 0, err
2273	}
2274	i += n50
2275	dAtA[i] = 0x1a
2276	i++
2277	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2278	n51, err := m.Status.MarshalTo(dAtA[i:])
2279	if err != nil {
2280		return 0, err
2281	}
2282	i += n51
2283	return i, nil
2284}
2285
2286func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
2287	size := m.Size()
2288	dAtA = make([]byte, size)
2289	n, err := m.MarshalTo(dAtA)
2290	if err != nil {
2291		return nil, err
2292	}
2293	return dAtA[:n], nil
2294}
2295
2296func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
2297	var i int
2298	_ = i
2299	var l int
2300	_ = l
2301	dAtA[i] = 0xa
2302	i++
2303	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2304	i += copy(dAtA[i:], m.Type)
2305	dAtA[i] = 0x12
2306	i++
2307	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
2308	i += copy(dAtA[i:], m.Status)
2309	dAtA[i] = 0x1a
2310	i++
2311	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
2312	n52, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
2313	if err != nil {
2314		return 0, err
2315	}
2316	i += n52
2317	dAtA[i] = 0x22
2318	i++
2319	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
2320	i += copy(dAtA[i:], m.Reason)
2321	dAtA[i] = 0x2a
2322	i++
2323	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
2324	i += copy(dAtA[i:], m.Message)
2325	return i, nil
2326}
2327
2328func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
2329	size := m.Size()
2330	dAtA = make([]byte, size)
2331	n, err := m.MarshalTo(dAtA)
2332	if err != nil {
2333		return nil, err
2334	}
2335	return dAtA[:n], nil
2336}
2337
2338func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
2339	var i int
2340	_ = i
2341	var l int
2342	_ = l
2343	dAtA[i] = 0xa
2344	i++
2345	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
2346	n53, err := m.ListMeta.MarshalTo(dAtA[i:])
2347	if err != nil {
2348		return 0, err
2349	}
2350	i += n53
2351	if len(m.Items) > 0 {
2352		for _, msg := range m.Items {
2353			dAtA[i] = 0x12
2354			i++
2355			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2356			n, err := msg.MarshalTo(dAtA[i:])
2357			if err != nil {
2358				return 0, err
2359			}
2360			i += n
2361		}
2362	}
2363	return i, nil
2364}
2365
2366func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
2367	size := m.Size()
2368	dAtA = make([]byte, size)
2369	n, err := m.MarshalTo(dAtA)
2370	if err != nil {
2371		return nil, err
2372	}
2373	return dAtA[:n], nil
2374}
2375
2376func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
2377	var i int
2378	_ = i
2379	var l int
2380	_ = l
2381	if m.Replicas != nil {
2382		dAtA[i] = 0x8
2383		i++
2384		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
2385	}
2386	if m.Selector != nil {
2387		dAtA[i] = 0x12
2388		i++
2389		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
2390		n54, err := m.Selector.MarshalTo(dAtA[i:])
2391		if err != nil {
2392			return 0, err
2393		}
2394		i += n54
2395	}
2396	dAtA[i] = 0x1a
2397	i++
2398	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
2399	n55, err := m.Template.MarshalTo(dAtA[i:])
2400	if err != nil {
2401		return 0, err
2402	}
2403	i += n55
2404	dAtA[i] = 0x20
2405	i++
2406	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
2407	return i, nil
2408}
2409
2410func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
2411	size := m.Size()
2412	dAtA = make([]byte, size)
2413	n, err := m.MarshalTo(dAtA)
2414	if err != nil {
2415		return nil, err
2416	}
2417	return dAtA[:n], nil
2418}
2419
2420func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
2421	var i int
2422	_ = i
2423	var l int
2424	_ = l
2425	dAtA[i] = 0x8
2426	i++
2427	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2428	dAtA[i] = 0x10
2429	i++
2430	i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
2431	dAtA[i] = 0x18
2432	i++
2433	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
2434	dAtA[i] = 0x20
2435	i++
2436	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2437	dAtA[i] = 0x28
2438	i++
2439	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
2440	if len(m.Conditions) > 0 {
2441		for _, msg := range m.Conditions {
2442			dAtA[i] = 0x32
2443			i++
2444			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2445			n, err := msg.MarshalTo(dAtA[i:])
2446			if err != nil {
2447				return 0, err
2448			}
2449			i += n
2450		}
2451	}
2452	return i, nil
2453}
2454
2455func (m *ReplicationControllerDummy) Marshal() (dAtA []byte, err error) {
2456	size := m.Size()
2457	dAtA = make([]byte, size)
2458	n, err := m.MarshalTo(dAtA)
2459	if err != nil {
2460		return nil, err
2461	}
2462	return dAtA[:n], nil
2463}
2464
2465func (m *ReplicationControllerDummy) MarshalTo(dAtA []byte) (int, error) {
2466	var i int
2467	_ = i
2468	var l int
2469	_ = l
2470	return i, nil
2471}
2472
2473func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
2474	size := m.Size()
2475	dAtA = make([]byte, size)
2476	n, err := m.MarshalTo(dAtA)
2477	if err != nil {
2478		return nil, err
2479	}
2480	return dAtA[:n], nil
2481}
2482
2483func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
2484	var i int
2485	_ = i
2486	var l int
2487	_ = l
2488	dAtA[i] = 0x8
2489	i++
2490	i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
2491	return i, nil
2492}
2493
2494func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
2495	size := m.Size()
2496	dAtA = make([]byte, size)
2497	n, err := m.MarshalTo(dAtA)
2498	if err != nil {
2499		return nil, err
2500	}
2501	return dAtA[:n], nil
2502}
2503
2504func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
2505	var i int
2506	_ = i
2507	var l int
2508	_ = l
2509	if m.MaxUnavailable != nil {
2510		dAtA[i] = 0xa
2511		i++
2512		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2513		n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2514		if err != nil {
2515			return 0, err
2516		}
2517		i += n56
2518	}
2519	return i, nil
2520}
2521
2522func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
2523	size := m.Size()
2524	dAtA = make([]byte, size)
2525	n, err := m.MarshalTo(dAtA)
2526	if err != nil {
2527		return nil, err
2528	}
2529	return dAtA[:n], nil
2530}
2531
2532func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
2533	var i int
2534	_ = i
2535	var l int
2536	_ = l
2537	if m.MaxUnavailable != nil {
2538		dAtA[i] = 0xa
2539		i++
2540		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2541		n57, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2542		if err != nil {
2543			return 0, err
2544		}
2545		i += n57
2546	}
2547	if m.MaxSurge != nil {
2548		dAtA[i] = 0x12
2549		i++
2550		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
2551		n58, err := m.MaxSurge.MarshalTo(dAtA[i:])
2552		if err != nil {
2553			return 0, err
2554		}
2555		i += n58
2556	}
2557	return i, nil
2558}
2559
2560func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
2561	size := m.Size()
2562	dAtA = make([]byte, size)
2563	n, err := m.MarshalTo(dAtA)
2564	if err != nil {
2565		return nil, err
2566	}
2567	return dAtA[:n], nil
2568}
2569
2570func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2571	var i int
2572	_ = i
2573	var l int
2574	_ = l
2575	dAtA[i] = 0xa
2576	i++
2577	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2578	i += copy(dAtA[i:], m.Rule)
2579	if len(m.Ranges) > 0 {
2580		for _, msg := range m.Ranges {
2581			dAtA[i] = 0x12
2582			i++
2583			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2584			n, err := msg.MarshalTo(dAtA[i:])
2585			if err != nil {
2586				return 0, err
2587			}
2588			i += n
2589		}
2590	}
2591	return i, nil
2592}
2593
2594func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) {
2595	size := m.Size()
2596	dAtA = make([]byte, size)
2597	n, err := m.MarshalTo(dAtA)
2598	if err != nil {
2599		return nil, err
2600	}
2601	return dAtA[:n], nil
2602}
2603
2604func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2605	var i int
2606	_ = i
2607	var l int
2608	_ = l
2609	dAtA[i] = 0xa
2610	i++
2611	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2612	i += copy(dAtA[i:], m.Rule)
2613	if len(m.Ranges) > 0 {
2614		for _, msg := range m.Ranges {
2615			dAtA[i] = 0x12
2616			i++
2617			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2618			n, err := msg.MarshalTo(dAtA[i:])
2619			if err != nil {
2620				return 0, err
2621			}
2622			i += n
2623		}
2624	}
2625	return i, nil
2626}
2627
2628func (m *RuntimeClassStrategyOptions) Marshal() (dAtA []byte, err error) {
2629	size := m.Size()
2630	dAtA = make([]byte, size)
2631	n, err := m.MarshalTo(dAtA)
2632	if err != nil {
2633		return nil, err
2634	}
2635	return dAtA[:n], nil
2636}
2637
2638func (m *RuntimeClassStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2639	var i int
2640	_ = i
2641	var l int
2642	_ = l
2643	if len(m.AllowedRuntimeClassNames) > 0 {
2644		for _, s := range m.AllowedRuntimeClassNames {
2645			dAtA[i] = 0xa
2646			i++
2647			l = len(s)
2648			for l >= 1<<7 {
2649				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2650				l >>= 7
2651				i++
2652			}
2653			dAtA[i] = uint8(l)
2654			i++
2655			i += copy(dAtA[i:], s)
2656		}
2657	}
2658	if m.DefaultRuntimeClassName != nil {
2659		dAtA[i] = 0x12
2660		i++
2661		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.DefaultRuntimeClassName)))
2662		i += copy(dAtA[i:], *m.DefaultRuntimeClassName)
2663	}
2664	return i, nil
2665}
2666
2667func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) {
2668	size := m.Size()
2669	dAtA = make([]byte, size)
2670	n, err := m.MarshalTo(dAtA)
2671	if err != nil {
2672		return nil, err
2673	}
2674	return dAtA[:n], nil
2675}
2676
2677func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2678	var i int
2679	_ = i
2680	var l int
2681	_ = l
2682	dAtA[i] = 0xa
2683	i++
2684	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2685	i += copy(dAtA[i:], m.Rule)
2686	if m.SELinuxOptions != nil {
2687		dAtA[i] = 0x12
2688		i++
2689		i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size()))
2690		n59, err := m.SELinuxOptions.MarshalTo(dAtA[i:])
2691		if err != nil {
2692			return 0, err
2693		}
2694		i += n59
2695	}
2696	return i, nil
2697}
2698
2699func (m *Scale) Marshal() (dAtA []byte, err error) {
2700	size := m.Size()
2701	dAtA = make([]byte, size)
2702	n, err := m.MarshalTo(dAtA)
2703	if err != nil {
2704		return nil, err
2705	}
2706	return dAtA[:n], nil
2707}
2708
2709func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
2710	var i int
2711	_ = i
2712	var l int
2713	_ = l
2714	dAtA[i] = 0xa
2715	i++
2716	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2717	n60, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2718	if err != nil {
2719		return 0, err
2720	}
2721	i += n60
2722	dAtA[i] = 0x12
2723	i++
2724	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2725	n61, err := m.Spec.MarshalTo(dAtA[i:])
2726	if err != nil {
2727		return 0, err
2728	}
2729	i += n61
2730	dAtA[i] = 0x1a
2731	i++
2732	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2733	n62, err := m.Status.MarshalTo(dAtA[i:])
2734	if err != nil {
2735		return 0, err
2736	}
2737	i += n62
2738	return i, nil
2739}
2740
2741func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
2742	size := m.Size()
2743	dAtA = make([]byte, size)
2744	n, err := m.MarshalTo(dAtA)
2745	if err != nil {
2746		return nil, err
2747	}
2748	return dAtA[:n], nil
2749}
2750
2751func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
2752	var i int
2753	_ = i
2754	var l int
2755	_ = l
2756	dAtA[i] = 0x8
2757	i++
2758	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2759	return i, nil
2760}
2761
2762func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
2763	size := m.Size()
2764	dAtA = make([]byte, size)
2765	n, err := m.MarshalTo(dAtA)
2766	if err != nil {
2767		return nil, err
2768	}
2769	return dAtA[:n], nil
2770}
2771
2772func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
2773	var i int
2774	_ = i
2775	var l int
2776	_ = l
2777	dAtA[i] = 0x8
2778	i++
2779	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2780	if len(m.Selector) > 0 {
2781		keysForSelector := make([]string, 0, len(m.Selector))
2782		for k := range m.Selector {
2783			keysForSelector = append(keysForSelector, string(k))
2784		}
2785		github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
2786		for _, k := range keysForSelector {
2787			dAtA[i] = 0x12
2788			i++
2789			v := m.Selector[string(k)]
2790			mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2791			i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
2792			dAtA[i] = 0xa
2793			i++
2794			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
2795			i += copy(dAtA[i:], k)
2796			dAtA[i] = 0x12
2797			i++
2798			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
2799			i += copy(dAtA[i:], v)
2800		}
2801	}
2802	dAtA[i] = 0x1a
2803	i++
2804	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
2805	i += copy(dAtA[i:], m.TargetSelector)
2806	return i, nil
2807}
2808
2809func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) {
2810	size := m.Size()
2811	dAtA = make([]byte, size)
2812	n, err := m.MarshalTo(dAtA)
2813	if err != nil {
2814		return nil, err
2815	}
2816	return dAtA[:n], nil
2817}
2818
2819func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2820	var i int
2821	_ = i
2822	var l int
2823	_ = l
2824	dAtA[i] = 0xa
2825	i++
2826	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2827	i += copy(dAtA[i:], m.Rule)
2828	if len(m.Ranges) > 0 {
2829		for _, msg := range m.Ranges {
2830			dAtA[i] = 0x12
2831			i++
2832			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2833			n, err := msg.MarshalTo(dAtA[i:])
2834			if err != nil {
2835				return 0, err
2836			}
2837			i += n
2838		}
2839	}
2840	return i, nil
2841}
2842
2843func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2844	for v >= 1<<7 {
2845		dAtA[offset] = uint8(v&0x7f | 0x80)
2846		v >>= 7
2847		offset++
2848	}
2849	dAtA[offset] = uint8(v)
2850	return offset + 1
2851}
2852func (m *AllowedCSIDriver) Size() (n int) {
2853	var l int
2854	_ = l
2855	l = len(m.Name)
2856	n += 1 + l + sovGenerated(uint64(l))
2857	return n
2858}
2859
2860func (m *AllowedFlexVolume) Size() (n int) {
2861	var l int
2862	_ = l
2863	l = len(m.Driver)
2864	n += 1 + l + sovGenerated(uint64(l))
2865	return n
2866}
2867
2868func (m *AllowedHostPath) Size() (n int) {
2869	var l int
2870	_ = l
2871	l = len(m.PathPrefix)
2872	n += 1 + l + sovGenerated(uint64(l))
2873	n += 2
2874	return n
2875}
2876
2877func (m *DaemonSet) Size() (n int) {
2878	var l int
2879	_ = l
2880	l = m.ObjectMeta.Size()
2881	n += 1 + l + sovGenerated(uint64(l))
2882	l = m.Spec.Size()
2883	n += 1 + l + sovGenerated(uint64(l))
2884	l = m.Status.Size()
2885	n += 1 + l + sovGenerated(uint64(l))
2886	return n
2887}
2888
2889func (m *DaemonSetCondition) Size() (n int) {
2890	var l int
2891	_ = l
2892	l = len(m.Type)
2893	n += 1 + l + sovGenerated(uint64(l))
2894	l = len(m.Status)
2895	n += 1 + l + sovGenerated(uint64(l))
2896	l = m.LastTransitionTime.Size()
2897	n += 1 + l + sovGenerated(uint64(l))
2898	l = len(m.Reason)
2899	n += 1 + l + sovGenerated(uint64(l))
2900	l = len(m.Message)
2901	n += 1 + l + sovGenerated(uint64(l))
2902	return n
2903}
2904
2905func (m *DaemonSetList) Size() (n int) {
2906	var l int
2907	_ = l
2908	l = m.ListMeta.Size()
2909	n += 1 + l + sovGenerated(uint64(l))
2910	if len(m.Items) > 0 {
2911		for _, e := range m.Items {
2912			l = e.Size()
2913			n += 1 + l + sovGenerated(uint64(l))
2914		}
2915	}
2916	return n
2917}
2918
2919func (m *DaemonSetSpec) Size() (n int) {
2920	var l int
2921	_ = l
2922	if m.Selector != nil {
2923		l = m.Selector.Size()
2924		n += 1 + l + sovGenerated(uint64(l))
2925	}
2926	l = m.Template.Size()
2927	n += 1 + l + sovGenerated(uint64(l))
2928	l = m.UpdateStrategy.Size()
2929	n += 1 + l + sovGenerated(uint64(l))
2930	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2931	n += 1 + sovGenerated(uint64(m.TemplateGeneration))
2932	if m.RevisionHistoryLimit != nil {
2933		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2934	}
2935	return n
2936}
2937
2938func (m *DaemonSetStatus) Size() (n int) {
2939	var l int
2940	_ = l
2941	n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
2942	n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
2943	n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
2944	n += 1 + sovGenerated(uint64(m.NumberReady))
2945	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2946	n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
2947	n += 1 + sovGenerated(uint64(m.NumberAvailable))
2948	n += 1 + sovGenerated(uint64(m.NumberUnavailable))
2949	if m.CollisionCount != nil {
2950		n += 1 + sovGenerated(uint64(*m.CollisionCount))
2951	}
2952	if len(m.Conditions) > 0 {
2953		for _, e := range m.Conditions {
2954			l = e.Size()
2955			n += 1 + l + sovGenerated(uint64(l))
2956		}
2957	}
2958	return n
2959}
2960
2961func (m *DaemonSetUpdateStrategy) Size() (n int) {
2962	var l int
2963	_ = l
2964	l = len(m.Type)
2965	n += 1 + l + sovGenerated(uint64(l))
2966	if m.RollingUpdate != nil {
2967		l = m.RollingUpdate.Size()
2968		n += 1 + l + sovGenerated(uint64(l))
2969	}
2970	return n
2971}
2972
2973func (m *Deployment) Size() (n int) {
2974	var l int
2975	_ = l
2976	l = m.ObjectMeta.Size()
2977	n += 1 + l + sovGenerated(uint64(l))
2978	l = m.Spec.Size()
2979	n += 1 + l + sovGenerated(uint64(l))
2980	l = m.Status.Size()
2981	n += 1 + l + sovGenerated(uint64(l))
2982	return n
2983}
2984
2985func (m *DeploymentCondition) Size() (n int) {
2986	var l int
2987	_ = l
2988	l = len(m.Type)
2989	n += 1 + l + sovGenerated(uint64(l))
2990	l = len(m.Status)
2991	n += 1 + l + sovGenerated(uint64(l))
2992	l = len(m.Reason)
2993	n += 1 + l + sovGenerated(uint64(l))
2994	l = len(m.Message)
2995	n += 1 + l + sovGenerated(uint64(l))
2996	l = m.LastUpdateTime.Size()
2997	n += 1 + l + sovGenerated(uint64(l))
2998	l = m.LastTransitionTime.Size()
2999	n += 1 + l + sovGenerated(uint64(l))
3000	return n
3001}
3002
3003func (m *DeploymentList) Size() (n int) {
3004	var l int
3005	_ = l
3006	l = m.ListMeta.Size()
3007	n += 1 + l + sovGenerated(uint64(l))
3008	if len(m.Items) > 0 {
3009		for _, e := range m.Items {
3010			l = e.Size()
3011			n += 1 + l + sovGenerated(uint64(l))
3012		}
3013	}
3014	return n
3015}
3016
3017func (m *DeploymentRollback) Size() (n int) {
3018	var l int
3019	_ = l
3020	l = len(m.Name)
3021	n += 1 + l + sovGenerated(uint64(l))
3022	if len(m.UpdatedAnnotations) > 0 {
3023		for k, v := range m.UpdatedAnnotations {
3024			_ = k
3025			_ = v
3026			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
3027			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
3028		}
3029	}
3030	l = m.RollbackTo.Size()
3031	n += 1 + l + sovGenerated(uint64(l))
3032	return n
3033}
3034
3035func (m *DeploymentSpec) Size() (n int) {
3036	var l int
3037	_ = l
3038	if m.Replicas != nil {
3039		n += 1 + sovGenerated(uint64(*m.Replicas))
3040	}
3041	if m.Selector != nil {
3042		l = m.Selector.Size()
3043		n += 1 + l + sovGenerated(uint64(l))
3044	}
3045	l = m.Template.Size()
3046	n += 1 + l + sovGenerated(uint64(l))
3047	l = m.Strategy.Size()
3048	n += 1 + l + sovGenerated(uint64(l))
3049	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3050	if m.RevisionHistoryLimit != nil {
3051		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
3052	}
3053	n += 2
3054	if m.RollbackTo != nil {
3055		l = m.RollbackTo.Size()
3056		n += 1 + l + sovGenerated(uint64(l))
3057	}
3058	if m.ProgressDeadlineSeconds != nil {
3059		n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
3060	}
3061	return n
3062}
3063
3064func (m *DeploymentStatus) Size() (n int) {
3065	var l int
3066	_ = l
3067	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3068	n += 1 + sovGenerated(uint64(m.Replicas))
3069	n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
3070	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3071	n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
3072	if len(m.Conditions) > 0 {
3073		for _, e := range m.Conditions {
3074			l = e.Size()
3075			n += 1 + l + sovGenerated(uint64(l))
3076		}
3077	}
3078	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3079	if m.CollisionCount != nil {
3080		n += 1 + sovGenerated(uint64(*m.CollisionCount))
3081	}
3082	return n
3083}
3084
3085func (m *DeploymentStrategy) Size() (n int) {
3086	var l int
3087	_ = l
3088	l = len(m.Type)
3089	n += 1 + l + sovGenerated(uint64(l))
3090	if m.RollingUpdate != nil {
3091		l = m.RollingUpdate.Size()
3092		n += 1 + l + sovGenerated(uint64(l))
3093	}
3094	return n
3095}
3096
3097func (m *FSGroupStrategyOptions) Size() (n int) {
3098	var l int
3099	_ = l
3100	l = len(m.Rule)
3101	n += 1 + l + sovGenerated(uint64(l))
3102	if len(m.Ranges) > 0 {
3103		for _, e := range m.Ranges {
3104			l = e.Size()
3105			n += 1 + l + sovGenerated(uint64(l))
3106		}
3107	}
3108	return n
3109}
3110
3111func (m *HTTPIngressPath) Size() (n int) {
3112	var l int
3113	_ = l
3114	l = len(m.Path)
3115	n += 1 + l + sovGenerated(uint64(l))
3116	l = m.Backend.Size()
3117	n += 1 + l + sovGenerated(uint64(l))
3118	return n
3119}
3120
3121func (m *HTTPIngressRuleValue) Size() (n int) {
3122	var l int
3123	_ = l
3124	if len(m.Paths) > 0 {
3125		for _, e := range m.Paths {
3126			l = e.Size()
3127			n += 1 + l + sovGenerated(uint64(l))
3128		}
3129	}
3130	return n
3131}
3132
3133func (m *HostPortRange) Size() (n int) {
3134	var l int
3135	_ = l
3136	n += 1 + sovGenerated(uint64(m.Min))
3137	n += 1 + sovGenerated(uint64(m.Max))
3138	return n
3139}
3140
3141func (m *IDRange) Size() (n int) {
3142	var l int
3143	_ = l
3144	n += 1 + sovGenerated(uint64(m.Min))
3145	n += 1 + sovGenerated(uint64(m.Max))
3146	return n
3147}
3148
3149func (m *IPBlock) Size() (n int) {
3150	var l int
3151	_ = l
3152	l = len(m.CIDR)
3153	n += 1 + l + sovGenerated(uint64(l))
3154	if len(m.Except) > 0 {
3155		for _, s := range m.Except {
3156			l = len(s)
3157			n += 1 + l + sovGenerated(uint64(l))
3158		}
3159	}
3160	return n
3161}
3162
3163func (m *Ingress) Size() (n int) {
3164	var l int
3165	_ = l
3166	l = m.ObjectMeta.Size()
3167	n += 1 + l + sovGenerated(uint64(l))
3168	l = m.Spec.Size()
3169	n += 1 + l + sovGenerated(uint64(l))
3170	l = m.Status.Size()
3171	n += 1 + l + sovGenerated(uint64(l))
3172	return n
3173}
3174
3175func (m *IngressBackend) Size() (n int) {
3176	var l int
3177	_ = l
3178	l = len(m.ServiceName)
3179	n += 1 + l + sovGenerated(uint64(l))
3180	l = m.ServicePort.Size()
3181	n += 1 + l + sovGenerated(uint64(l))
3182	return n
3183}
3184
3185func (m *IngressList) Size() (n int) {
3186	var l int
3187	_ = l
3188	l = m.ListMeta.Size()
3189	n += 1 + l + sovGenerated(uint64(l))
3190	if len(m.Items) > 0 {
3191		for _, e := range m.Items {
3192			l = e.Size()
3193			n += 1 + l + sovGenerated(uint64(l))
3194		}
3195	}
3196	return n
3197}
3198
3199func (m *IngressRule) Size() (n int) {
3200	var l int
3201	_ = l
3202	l = len(m.Host)
3203	n += 1 + l + sovGenerated(uint64(l))
3204	l = m.IngressRuleValue.Size()
3205	n += 1 + l + sovGenerated(uint64(l))
3206	return n
3207}
3208
3209func (m *IngressRuleValue) Size() (n int) {
3210	var l int
3211	_ = l
3212	if m.HTTP != nil {
3213		l = m.HTTP.Size()
3214		n += 1 + l + sovGenerated(uint64(l))
3215	}
3216	return n
3217}
3218
3219func (m *IngressSpec) Size() (n int) {
3220	var l int
3221	_ = l
3222	if m.Backend != nil {
3223		l = m.Backend.Size()
3224		n += 1 + l + sovGenerated(uint64(l))
3225	}
3226	if len(m.TLS) > 0 {
3227		for _, e := range m.TLS {
3228			l = e.Size()
3229			n += 1 + l + sovGenerated(uint64(l))
3230		}
3231	}
3232	if len(m.Rules) > 0 {
3233		for _, e := range m.Rules {
3234			l = e.Size()
3235			n += 1 + l + sovGenerated(uint64(l))
3236		}
3237	}
3238	return n
3239}
3240
3241func (m *IngressStatus) Size() (n int) {
3242	var l int
3243	_ = l
3244	l = m.LoadBalancer.Size()
3245	n += 1 + l + sovGenerated(uint64(l))
3246	return n
3247}
3248
3249func (m *IngressTLS) Size() (n int) {
3250	var l int
3251	_ = l
3252	if len(m.Hosts) > 0 {
3253		for _, s := range m.Hosts {
3254			l = len(s)
3255			n += 1 + l + sovGenerated(uint64(l))
3256		}
3257	}
3258	l = len(m.SecretName)
3259	n += 1 + l + sovGenerated(uint64(l))
3260	return n
3261}
3262
3263func (m *NetworkPolicy) Size() (n int) {
3264	var l int
3265	_ = l
3266	l = m.ObjectMeta.Size()
3267	n += 1 + l + sovGenerated(uint64(l))
3268	l = m.Spec.Size()
3269	n += 1 + l + sovGenerated(uint64(l))
3270	return n
3271}
3272
3273func (m *NetworkPolicyEgressRule) Size() (n int) {
3274	var l int
3275	_ = l
3276	if len(m.Ports) > 0 {
3277		for _, e := range m.Ports {
3278			l = e.Size()
3279			n += 1 + l + sovGenerated(uint64(l))
3280		}
3281	}
3282	if len(m.To) > 0 {
3283		for _, e := range m.To {
3284			l = e.Size()
3285			n += 1 + l + sovGenerated(uint64(l))
3286		}
3287	}
3288	return n
3289}
3290
3291func (m *NetworkPolicyIngressRule) Size() (n int) {
3292	var l int
3293	_ = l
3294	if len(m.Ports) > 0 {
3295		for _, e := range m.Ports {
3296			l = e.Size()
3297			n += 1 + l + sovGenerated(uint64(l))
3298		}
3299	}
3300	if len(m.From) > 0 {
3301		for _, e := range m.From {
3302			l = e.Size()
3303			n += 1 + l + sovGenerated(uint64(l))
3304		}
3305	}
3306	return n
3307}
3308
3309func (m *NetworkPolicyList) Size() (n int) {
3310	var l int
3311	_ = l
3312	l = m.ListMeta.Size()
3313	n += 1 + l + sovGenerated(uint64(l))
3314	if len(m.Items) > 0 {
3315		for _, e := range m.Items {
3316			l = e.Size()
3317			n += 1 + l + sovGenerated(uint64(l))
3318		}
3319	}
3320	return n
3321}
3322
3323func (m *NetworkPolicyPeer) Size() (n int) {
3324	var l int
3325	_ = l
3326	if m.PodSelector != nil {
3327		l = m.PodSelector.Size()
3328		n += 1 + l + sovGenerated(uint64(l))
3329	}
3330	if m.NamespaceSelector != nil {
3331		l = m.NamespaceSelector.Size()
3332		n += 1 + l + sovGenerated(uint64(l))
3333	}
3334	if m.IPBlock != nil {
3335		l = m.IPBlock.Size()
3336		n += 1 + l + sovGenerated(uint64(l))
3337	}
3338	return n
3339}
3340
3341func (m *NetworkPolicyPort) Size() (n int) {
3342	var l int
3343	_ = l
3344	if m.Protocol != nil {
3345		l = len(*m.Protocol)
3346		n += 1 + l + sovGenerated(uint64(l))
3347	}
3348	if m.Port != nil {
3349		l = m.Port.Size()
3350		n += 1 + l + sovGenerated(uint64(l))
3351	}
3352	return n
3353}
3354
3355func (m *NetworkPolicySpec) Size() (n int) {
3356	var l int
3357	_ = l
3358	l = m.PodSelector.Size()
3359	n += 1 + l + sovGenerated(uint64(l))
3360	if len(m.Ingress) > 0 {
3361		for _, e := range m.Ingress {
3362			l = e.Size()
3363			n += 1 + l + sovGenerated(uint64(l))
3364		}
3365	}
3366	if len(m.Egress) > 0 {
3367		for _, e := range m.Egress {
3368			l = e.Size()
3369			n += 1 + l + sovGenerated(uint64(l))
3370		}
3371	}
3372	if len(m.PolicyTypes) > 0 {
3373		for _, s := range m.PolicyTypes {
3374			l = len(s)
3375			n += 1 + l + sovGenerated(uint64(l))
3376		}
3377	}
3378	return n
3379}
3380
3381func (m *PodSecurityPolicy) Size() (n int) {
3382	var l int
3383	_ = l
3384	l = m.ObjectMeta.Size()
3385	n += 1 + l + sovGenerated(uint64(l))
3386	l = m.Spec.Size()
3387	n += 1 + l + sovGenerated(uint64(l))
3388	return n
3389}
3390
3391func (m *PodSecurityPolicyList) Size() (n int) {
3392	var l int
3393	_ = l
3394	l = m.ListMeta.Size()
3395	n += 1 + l + sovGenerated(uint64(l))
3396	if len(m.Items) > 0 {
3397		for _, e := range m.Items {
3398			l = e.Size()
3399			n += 1 + l + sovGenerated(uint64(l))
3400		}
3401	}
3402	return n
3403}
3404
3405func (m *PodSecurityPolicySpec) Size() (n int) {
3406	var l int
3407	_ = l
3408	n += 2
3409	if len(m.DefaultAddCapabilities) > 0 {
3410		for _, s := range m.DefaultAddCapabilities {
3411			l = len(s)
3412			n += 1 + l + sovGenerated(uint64(l))
3413		}
3414	}
3415	if len(m.RequiredDropCapabilities) > 0 {
3416		for _, s := range m.RequiredDropCapabilities {
3417			l = len(s)
3418			n += 1 + l + sovGenerated(uint64(l))
3419		}
3420	}
3421	if len(m.AllowedCapabilities) > 0 {
3422		for _, s := range m.AllowedCapabilities {
3423			l = len(s)
3424			n += 1 + l + sovGenerated(uint64(l))
3425		}
3426	}
3427	if len(m.Volumes) > 0 {
3428		for _, s := range m.Volumes {
3429			l = len(s)
3430			n += 1 + l + sovGenerated(uint64(l))
3431		}
3432	}
3433	n += 2
3434	if len(m.HostPorts) > 0 {
3435		for _, e := range m.HostPorts {
3436			l = e.Size()
3437			n += 1 + l + sovGenerated(uint64(l))
3438		}
3439	}
3440	n += 2
3441	n += 2
3442	l = m.SELinux.Size()
3443	n += 1 + l + sovGenerated(uint64(l))
3444	l = m.RunAsUser.Size()
3445	n += 1 + l + sovGenerated(uint64(l))
3446	l = m.SupplementalGroups.Size()
3447	n += 1 + l + sovGenerated(uint64(l))
3448	l = m.FSGroup.Size()
3449	n += 1 + l + sovGenerated(uint64(l))
3450	n += 2
3451	if m.DefaultAllowPrivilegeEscalation != nil {
3452		n += 2
3453	}
3454	if m.AllowPrivilegeEscalation != nil {
3455		n += 3
3456	}
3457	if len(m.AllowedHostPaths) > 0 {
3458		for _, e := range m.AllowedHostPaths {
3459			l = e.Size()
3460			n += 2 + l + sovGenerated(uint64(l))
3461		}
3462	}
3463	if len(m.AllowedFlexVolumes) > 0 {
3464		for _, e := range m.AllowedFlexVolumes {
3465			l = e.Size()
3466			n += 2 + l + sovGenerated(uint64(l))
3467		}
3468	}
3469	if len(m.AllowedUnsafeSysctls) > 0 {
3470		for _, s := range m.AllowedUnsafeSysctls {
3471			l = len(s)
3472			n += 2 + l + sovGenerated(uint64(l))
3473		}
3474	}
3475	if len(m.ForbiddenSysctls) > 0 {
3476		for _, s := range m.ForbiddenSysctls {
3477			l = len(s)
3478			n += 2 + l + sovGenerated(uint64(l))
3479		}
3480	}
3481	if len(m.AllowedProcMountTypes) > 0 {
3482		for _, s := range m.AllowedProcMountTypes {
3483			l = len(s)
3484			n += 2 + l + sovGenerated(uint64(l))
3485		}
3486	}
3487	if m.RunAsGroup != nil {
3488		l = m.RunAsGroup.Size()
3489		n += 2 + l + sovGenerated(uint64(l))
3490	}
3491	if len(m.AllowedCSIDrivers) > 0 {
3492		for _, e := range m.AllowedCSIDrivers {
3493			l = e.Size()
3494			n += 2 + l + sovGenerated(uint64(l))
3495		}
3496	}
3497	if m.RuntimeClass != nil {
3498		l = m.RuntimeClass.Size()
3499		n += 2 + l + sovGenerated(uint64(l))
3500	}
3501	return n
3502}
3503
3504func (m *ReplicaSet) Size() (n int) {
3505	var l int
3506	_ = l
3507	l = m.ObjectMeta.Size()
3508	n += 1 + l + sovGenerated(uint64(l))
3509	l = m.Spec.Size()
3510	n += 1 + l + sovGenerated(uint64(l))
3511	l = m.Status.Size()
3512	n += 1 + l + sovGenerated(uint64(l))
3513	return n
3514}
3515
3516func (m *ReplicaSetCondition) Size() (n int) {
3517	var l int
3518	_ = l
3519	l = len(m.Type)
3520	n += 1 + l + sovGenerated(uint64(l))
3521	l = len(m.Status)
3522	n += 1 + l + sovGenerated(uint64(l))
3523	l = m.LastTransitionTime.Size()
3524	n += 1 + l + sovGenerated(uint64(l))
3525	l = len(m.Reason)
3526	n += 1 + l + sovGenerated(uint64(l))
3527	l = len(m.Message)
3528	n += 1 + l + sovGenerated(uint64(l))
3529	return n
3530}
3531
3532func (m *ReplicaSetList) Size() (n int) {
3533	var l int
3534	_ = l
3535	l = m.ListMeta.Size()
3536	n += 1 + l + sovGenerated(uint64(l))
3537	if len(m.Items) > 0 {
3538		for _, e := range m.Items {
3539			l = e.Size()
3540			n += 1 + l + sovGenerated(uint64(l))
3541		}
3542	}
3543	return n
3544}
3545
3546func (m *ReplicaSetSpec) Size() (n int) {
3547	var l int
3548	_ = l
3549	if m.Replicas != nil {
3550		n += 1 + sovGenerated(uint64(*m.Replicas))
3551	}
3552	if m.Selector != nil {
3553		l = m.Selector.Size()
3554		n += 1 + l + sovGenerated(uint64(l))
3555	}
3556	l = m.Template.Size()
3557	n += 1 + l + sovGenerated(uint64(l))
3558	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3559	return n
3560}
3561
3562func (m *ReplicaSetStatus) Size() (n int) {
3563	var l int
3564	_ = l
3565	n += 1 + sovGenerated(uint64(m.Replicas))
3566	n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
3567	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3568	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3569	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3570	if len(m.Conditions) > 0 {
3571		for _, e := range m.Conditions {
3572			l = e.Size()
3573			n += 1 + l + sovGenerated(uint64(l))
3574		}
3575	}
3576	return n
3577}
3578
3579func (m *ReplicationControllerDummy) Size() (n int) {
3580	var l int
3581	_ = l
3582	return n
3583}
3584
3585func (m *RollbackConfig) Size() (n int) {
3586	var l int
3587	_ = l
3588	n += 1 + sovGenerated(uint64(m.Revision))
3589	return n
3590}
3591
3592func (m *RollingUpdateDaemonSet) Size() (n int) {
3593	var l int
3594	_ = l
3595	if m.MaxUnavailable != nil {
3596		l = m.MaxUnavailable.Size()
3597		n += 1 + l + sovGenerated(uint64(l))
3598	}
3599	return n
3600}
3601
3602func (m *RollingUpdateDeployment) Size() (n int) {
3603	var l int
3604	_ = l
3605	if m.MaxUnavailable != nil {
3606		l = m.MaxUnavailable.Size()
3607		n += 1 + l + sovGenerated(uint64(l))
3608	}
3609	if m.MaxSurge != nil {
3610		l = m.MaxSurge.Size()
3611		n += 1 + l + sovGenerated(uint64(l))
3612	}
3613	return n
3614}
3615
3616func (m *RunAsGroupStrategyOptions) Size() (n int) {
3617	var l int
3618	_ = l
3619	l = len(m.Rule)
3620	n += 1 + l + sovGenerated(uint64(l))
3621	if len(m.Ranges) > 0 {
3622		for _, e := range m.Ranges {
3623			l = e.Size()
3624			n += 1 + l + sovGenerated(uint64(l))
3625		}
3626	}
3627	return n
3628}
3629
3630func (m *RunAsUserStrategyOptions) Size() (n int) {
3631	var l int
3632	_ = l
3633	l = len(m.Rule)
3634	n += 1 + l + sovGenerated(uint64(l))
3635	if len(m.Ranges) > 0 {
3636		for _, e := range m.Ranges {
3637			l = e.Size()
3638			n += 1 + l + sovGenerated(uint64(l))
3639		}
3640	}
3641	return n
3642}
3643
3644func (m *RuntimeClassStrategyOptions) Size() (n int) {
3645	var l int
3646	_ = l
3647	if len(m.AllowedRuntimeClassNames) > 0 {
3648		for _, s := range m.AllowedRuntimeClassNames {
3649			l = len(s)
3650			n += 1 + l + sovGenerated(uint64(l))
3651		}
3652	}
3653	if m.DefaultRuntimeClassName != nil {
3654		l = len(*m.DefaultRuntimeClassName)
3655		n += 1 + l + sovGenerated(uint64(l))
3656	}
3657	return n
3658}
3659
3660func (m *SELinuxStrategyOptions) Size() (n int) {
3661	var l int
3662	_ = l
3663	l = len(m.Rule)
3664	n += 1 + l + sovGenerated(uint64(l))
3665	if m.SELinuxOptions != nil {
3666		l = m.SELinuxOptions.Size()
3667		n += 1 + l + sovGenerated(uint64(l))
3668	}
3669	return n
3670}
3671
3672func (m *Scale) Size() (n int) {
3673	var l int
3674	_ = l
3675	l = m.ObjectMeta.Size()
3676	n += 1 + l + sovGenerated(uint64(l))
3677	l = m.Spec.Size()
3678	n += 1 + l + sovGenerated(uint64(l))
3679	l = m.Status.Size()
3680	n += 1 + l + sovGenerated(uint64(l))
3681	return n
3682}
3683
3684func (m *ScaleSpec) Size() (n int) {
3685	var l int
3686	_ = l
3687	n += 1 + sovGenerated(uint64(m.Replicas))
3688	return n
3689}
3690
3691func (m *ScaleStatus) Size() (n int) {
3692	var l int
3693	_ = l
3694	n += 1 + sovGenerated(uint64(m.Replicas))
3695	if len(m.Selector) > 0 {
3696		for k, v := range m.Selector {
3697			_ = k
3698			_ = v
3699			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
3700			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
3701		}
3702	}
3703	l = len(m.TargetSelector)
3704	n += 1 + l + sovGenerated(uint64(l))
3705	return n
3706}
3707
3708func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
3709	var l int
3710	_ = l
3711	l = len(m.Rule)
3712	n += 1 + l + sovGenerated(uint64(l))
3713	if len(m.Ranges) > 0 {
3714		for _, e := range m.Ranges {
3715			l = e.Size()
3716			n += 1 + l + sovGenerated(uint64(l))
3717		}
3718	}
3719	return n
3720}
3721
3722func sovGenerated(x uint64) (n int) {
3723	for {
3724		n++
3725		x >>= 7
3726		if x == 0 {
3727			break
3728		}
3729	}
3730	return n
3731}
3732func sozGenerated(x uint64) (n int) {
3733	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3734}
3735func (this *AllowedCSIDriver) String() string {
3736	if this == nil {
3737		return "nil"
3738	}
3739	s := strings.Join([]string{`&AllowedCSIDriver{`,
3740		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3741		`}`,
3742	}, "")
3743	return s
3744}
3745func (this *AllowedFlexVolume) String() string {
3746	if this == nil {
3747		return "nil"
3748	}
3749	s := strings.Join([]string{`&AllowedFlexVolume{`,
3750		`Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
3751		`}`,
3752	}, "")
3753	return s
3754}
3755func (this *AllowedHostPath) String() string {
3756	if this == nil {
3757		return "nil"
3758	}
3759	s := strings.Join([]string{`&AllowedHostPath{`,
3760		`PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`,
3761		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
3762		`}`,
3763	}, "")
3764	return s
3765}
3766func (this *DaemonSet) String() string {
3767	if this == nil {
3768		return "nil"
3769	}
3770	s := strings.Join([]string{`&DaemonSet{`,
3771		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3772		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
3773		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
3774		`}`,
3775	}, "")
3776	return s
3777}
3778func (this *DaemonSetCondition) String() string {
3779	if this == nil {
3780		return "nil"
3781	}
3782	s := strings.Join([]string{`&DaemonSetCondition{`,
3783		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3784		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3785		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3786		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3787		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3788		`}`,
3789	}, "")
3790	return s
3791}
3792func (this *DaemonSetList) String() string {
3793	if this == nil {
3794		return "nil"
3795	}
3796	s := strings.Join([]string{`&DaemonSetList{`,
3797		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3798		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`,
3799		`}`,
3800	}, "")
3801	return s
3802}
3803func (this *DaemonSetSpec) String() string {
3804	if this == nil {
3805		return "nil"
3806	}
3807	s := strings.Join([]string{`&DaemonSetSpec{`,
3808		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3809		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3810		`UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
3811		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3812		`TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`,
3813		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3814		`}`,
3815	}, "")
3816	return s
3817}
3818func (this *DaemonSetStatus) String() string {
3819	if this == nil {
3820		return "nil"
3821	}
3822	s := strings.Join([]string{`&DaemonSetStatus{`,
3823		`CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
3824		`NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
3825		`DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
3826		`NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
3827		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3828		`UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
3829		`NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
3830		`NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
3831		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3832		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`,
3833		`}`,
3834	}, "")
3835	return s
3836}
3837func (this *DaemonSetUpdateStrategy) String() string {
3838	if this == nil {
3839		return "nil"
3840	}
3841	s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
3842		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3843		`RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
3844		`}`,
3845	}, "")
3846	return s
3847}
3848func (this *Deployment) String() string {
3849	if this == nil {
3850		return "nil"
3851	}
3852	s := strings.Join([]string{`&Deployment{`,
3853		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3854		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
3855		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
3856		`}`,
3857	}, "")
3858	return s
3859}
3860func (this *DeploymentCondition) String() string {
3861	if this == nil {
3862		return "nil"
3863	}
3864	s := strings.Join([]string{`&DeploymentCondition{`,
3865		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3866		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3867		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3868		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3869		`LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3870		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3871		`}`,
3872	}, "")
3873	return s
3874}
3875func (this *DeploymentList) String() string {
3876	if this == nil {
3877		return "nil"
3878	}
3879	s := strings.Join([]string{`&DeploymentList{`,
3880		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3881		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`,
3882		`}`,
3883	}, "")
3884	return s
3885}
3886func (this *DeploymentRollback) String() string {
3887	if this == nil {
3888		return "nil"
3889	}
3890	keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
3891	for k := range this.UpdatedAnnotations {
3892		keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
3893	}
3894	github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
3895	mapStringForUpdatedAnnotations := "map[string]string{"
3896	for _, k := range keysForUpdatedAnnotations {
3897		mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
3898	}
3899	mapStringForUpdatedAnnotations += "}"
3900	s := strings.Join([]string{`&DeploymentRollback{`,
3901		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3902		`UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
3903		`RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
3904		`}`,
3905	}, "")
3906	return s
3907}
3908func (this *DeploymentSpec) String() string {
3909	if this == nil {
3910		return "nil"
3911	}
3912	s := strings.Join([]string{`&DeploymentSpec{`,
3913		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3914		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3915		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3916		`Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
3917		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3918		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3919		`Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
3920		`RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`,
3921		`ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
3922		`}`,
3923	}, "")
3924	return s
3925}
3926func (this *DeploymentStatus) String() string {
3927	if this == nil {
3928		return "nil"
3929	}
3930	s := strings.Join([]string{`&DeploymentStatus{`,
3931		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3932		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3933		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
3934		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3935		`UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
3936		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`,
3937		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3938		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3939		`}`,
3940	}, "")
3941	return s
3942}
3943func (this *DeploymentStrategy) String() string {
3944	if this == nil {
3945		return "nil"
3946	}
3947	s := strings.Join([]string{`&DeploymentStrategy{`,
3948		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3949		`RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
3950		`}`,
3951	}, "")
3952	return s
3953}
3954func (this *FSGroupStrategyOptions) String() string {
3955	if this == nil {
3956		return "nil"
3957	}
3958	s := strings.Join([]string{`&FSGroupStrategyOptions{`,
3959		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
3960		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
3961		`}`,
3962	}, "")
3963	return s
3964}
3965func (this *HTTPIngressPath) String() string {
3966	if this == nil {
3967		return "nil"
3968	}
3969	s := strings.Join([]string{`&HTTPIngressPath{`,
3970		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
3971		`Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`,
3972		`}`,
3973	}, "")
3974	return s
3975}
3976func (this *HTTPIngressRuleValue) String() string {
3977	if this == nil {
3978		return "nil"
3979	}
3980	s := strings.Join([]string{`&HTTPIngressRuleValue{`,
3981		`Paths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Paths), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + `,`,
3982		`}`,
3983	}, "")
3984	return s
3985}
3986func (this *HostPortRange) String() string {
3987	if this == nil {
3988		return "nil"
3989	}
3990	s := strings.Join([]string{`&HostPortRange{`,
3991		`Min:` + fmt.Sprintf("%v", this.Min) + `,`,
3992		`Max:` + fmt.Sprintf("%v", this.Max) + `,`,
3993		`}`,
3994	}, "")
3995	return s
3996}
3997func (this *IDRange) String() string {
3998	if this == nil {
3999		return "nil"
4000	}
4001	s := strings.Join([]string{`&IDRange{`,
4002		`Min:` + fmt.Sprintf("%v", this.Min) + `,`,
4003		`Max:` + fmt.Sprintf("%v", this.Max) + `,`,
4004		`}`,
4005	}, "")
4006	return s
4007}
4008func (this *IPBlock) String() string {
4009	if this == nil {
4010		return "nil"
4011	}
4012	s := strings.Join([]string{`&IPBlock{`,
4013		`CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`,
4014		`Except:` + fmt.Sprintf("%v", this.Except) + `,`,
4015		`}`,
4016	}, "")
4017	return s
4018}
4019func (this *Ingress) String() string {
4020	if this == nil {
4021		return "nil"
4022	}
4023	s := strings.Join([]string{`&Ingress{`,
4024		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4025		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`,
4026		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`,
4027		`}`,
4028	}, "")
4029	return s
4030}
4031func (this *IngressBackend) String() string {
4032	if this == nil {
4033		return "nil"
4034	}
4035	s := strings.Join([]string{`&IngressBackend{`,
4036		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
4037		`ServicePort:` + strings.Replace(strings.Replace(this.ServicePort.String(), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1), `&`, ``, 1) + `,`,
4038		`}`,
4039	}, "")
4040	return s
4041}
4042func (this *IngressList) String() string {
4043	if this == nil {
4044		return "nil"
4045	}
4046	s := strings.Join([]string{`&IngressList{`,
4047		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4048		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Ingress", "Ingress", 1), `&`, ``, 1) + `,`,
4049		`}`,
4050	}, "")
4051	return s
4052}
4053func (this *IngressRule) String() string {
4054	if this == nil {
4055		return "nil"
4056	}
4057	s := strings.Join([]string{`&IngressRule{`,
4058		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
4059		`IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`,
4060		`}`,
4061	}, "")
4062	return s
4063}
4064func (this *IngressRuleValue) String() string {
4065	if this == nil {
4066		return "nil"
4067	}
4068	s := strings.Join([]string{`&IngressRuleValue{`,
4069		`HTTP:` + strings.Replace(fmt.Sprintf("%v", this.HTTP), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`,
4070		`}`,
4071	}, "")
4072	return s
4073}
4074func (this *IngressSpec) String() string {
4075	if this == nil {
4076		return "nil"
4077	}
4078	s := strings.Join([]string{`&IngressSpec{`,
4079		`Backend:` + strings.Replace(fmt.Sprintf("%v", this.Backend), "IngressBackend", "IngressBackend", 1) + `,`,
4080		`TLS:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TLS), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + `,`,
4081		`Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "IngressRule", "IngressRule", 1), `&`, ``, 1) + `,`,
4082		`}`,
4083	}, "")
4084	return s
4085}
4086func (this *IngressStatus) String() string {
4087	if this == nil {
4088		return "nil"
4089	}
4090	s := strings.Join([]string{`&IngressStatus{`,
4091		`LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "LoadBalancerStatus", "k8s_io_api_core_v1.LoadBalancerStatus", 1), `&`, ``, 1) + `,`,
4092		`}`,
4093	}, "")
4094	return s
4095}
4096func (this *IngressTLS) String() string {
4097	if this == nil {
4098		return "nil"
4099	}
4100	s := strings.Join([]string{`&IngressTLS{`,
4101		`Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`,
4102		`SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`,
4103		`}`,
4104	}, "")
4105	return s
4106}
4107func (this *NetworkPolicy) String() string {
4108	if this == nil {
4109		return "nil"
4110	}
4111	s := strings.Join([]string{`&NetworkPolicy{`,
4112		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4113		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`,
4114		`}`,
4115	}, "")
4116	return s
4117}
4118func (this *NetworkPolicyEgressRule) String() string {
4119	if this == nil {
4120		return "nil"
4121	}
4122	s := strings.Join([]string{`&NetworkPolicyEgressRule{`,
4123		`Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
4124		`To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
4125		`}`,
4126	}, "")
4127	return s
4128}
4129func (this *NetworkPolicyIngressRule) String() string {
4130	if this == nil {
4131		return "nil"
4132	}
4133	s := strings.Join([]string{`&NetworkPolicyIngressRule{`,
4134		`Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
4135		`From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
4136		`}`,
4137	}, "")
4138	return s
4139}
4140func (this *NetworkPolicyList) String() string {
4141	if this == nil {
4142		return "nil"
4143	}
4144	s := strings.Join([]string{`&NetworkPolicyList{`,
4145		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4146		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + `,`,
4147		`}`,
4148	}, "")
4149	return s
4150}
4151func (this *NetworkPolicyPeer) String() string {
4152	if this == nil {
4153		return "nil"
4154	}
4155	s := strings.Join([]string{`&NetworkPolicyPeer{`,
4156		`PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4157		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4158		`IPBlock:` + strings.Replace(fmt.Sprintf("%v", this.IPBlock), "IPBlock", "IPBlock", 1) + `,`,
4159		`}`,
4160	}, "")
4161	return s
4162}
4163func (this *NetworkPolicyPort) String() string {
4164	if this == nil {
4165		return "nil"
4166	}
4167	s := strings.Join([]string{`&NetworkPolicyPort{`,
4168		`Protocol:` + valueToStringGenerated(this.Protocol) + `,`,
4169		`Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4170		`}`,
4171	}, "")
4172	return s
4173}
4174func (this *NetworkPolicySpec) String() string {
4175	if this == nil {
4176		return "nil"
4177	}
4178	s := strings.Join([]string{`&NetworkPolicySpec{`,
4179		`PodSelector:` + strings.Replace(strings.Replace(this.PodSelector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`,
4180		`Ingress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ingress), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + `,`,
4181		`Egress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Egress), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + `,`,
4182		`PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`,
4183		`}`,
4184	}, "")
4185	return s
4186}
4187func (this *PodSecurityPolicy) String() string {
4188	if this == nil {
4189		return "nil"
4190	}
4191	s := strings.Join([]string{`&PodSecurityPolicy{`,
4192		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4193		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`,
4194		`}`,
4195	}, "")
4196	return s
4197}
4198func (this *PodSecurityPolicyList) String() string {
4199	if this == nil {
4200		return "nil"
4201	}
4202	s := strings.Join([]string{`&PodSecurityPolicyList{`,
4203		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4204		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`,
4205		`}`,
4206	}, "")
4207	return s
4208}
4209func (this *PodSecurityPolicySpec) String() string {
4210	if this == nil {
4211		return "nil"
4212	}
4213	s := strings.Join([]string{`&PodSecurityPolicySpec{`,
4214		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
4215		`DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`,
4216		`RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`,
4217		`AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`,
4218		`Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`,
4219		`HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`,
4220		`HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`,
4221		`HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`,
4222		`HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`,
4223		`SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`,
4224		`RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`,
4225		`SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`,
4226		`FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`,
4227		`ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`,
4228		`DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`,
4229		`AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`,
4230		`AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`,
4231		`AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`,
4232		`AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`,
4233		`ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`,
4234		`AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`,
4235		`RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`,
4236		`AllowedCSIDrivers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedCSIDrivers), "AllowedCSIDriver", "AllowedCSIDriver", 1), `&`, ``, 1) + `,`,
4237		`RuntimeClass:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeClass), "RuntimeClassStrategyOptions", "RuntimeClassStrategyOptions", 1) + `,`,
4238		`}`,
4239	}, "")
4240	return s
4241}
4242func (this *ReplicaSet) String() string {
4243	if this == nil {
4244		return "nil"
4245	}
4246	s := strings.Join([]string{`&ReplicaSet{`,
4247		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4248		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
4249		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
4250		`}`,
4251	}, "")
4252	return s
4253}
4254func (this *ReplicaSetCondition) String() string {
4255	if this == nil {
4256		return "nil"
4257	}
4258	s := strings.Join([]string{`&ReplicaSetCondition{`,
4259		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4260		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
4261		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
4262		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
4263		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
4264		`}`,
4265	}, "")
4266	return s
4267}
4268func (this *ReplicaSetList) String() string {
4269	if this == nil {
4270		return "nil"
4271	}
4272	s := strings.Join([]string{`&ReplicaSetList{`,
4273		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4274		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`,
4275		`}`,
4276	}, "")
4277	return s
4278}
4279func (this *ReplicaSetSpec) String() string {
4280	if this == nil {
4281		return "nil"
4282	}
4283	s := strings.Join([]string{`&ReplicaSetSpec{`,
4284		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
4285		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4286		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
4287		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
4288		`}`,
4289	}, "")
4290	return s
4291}
4292func (this *ReplicaSetStatus) String() string {
4293	if this == nil {
4294		return "nil"
4295	}
4296	s := strings.Join([]string{`&ReplicaSetStatus{`,
4297		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4298		`FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
4299		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
4300		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
4301		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
4302		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`,
4303		`}`,
4304	}, "")
4305	return s
4306}
4307func (this *ReplicationControllerDummy) String() string {
4308	if this == nil {
4309		return "nil"
4310	}
4311	s := strings.Join([]string{`&ReplicationControllerDummy{`,
4312		`}`,
4313	}, "")
4314	return s
4315}
4316func (this *RollbackConfig) String() string {
4317	if this == nil {
4318		return "nil"
4319	}
4320	s := strings.Join([]string{`&RollbackConfig{`,
4321		`Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
4322		`}`,
4323	}, "")
4324	return s
4325}
4326func (this *RollingUpdateDaemonSet) String() string {
4327	if this == nil {
4328		return "nil"
4329	}
4330	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
4331		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4332		`}`,
4333	}, "")
4334	return s
4335}
4336func (this *RollingUpdateDeployment) String() string {
4337	if this == nil {
4338		return "nil"
4339	}
4340	s := strings.Join([]string{`&RollingUpdateDeployment{`,
4341		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4342		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4343		`}`,
4344	}, "")
4345	return s
4346}
4347func (this *RunAsGroupStrategyOptions) String() string {
4348	if this == nil {
4349		return "nil"
4350	}
4351	s := strings.Join([]string{`&RunAsGroupStrategyOptions{`,
4352		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4353		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4354		`}`,
4355	}, "")
4356	return s
4357}
4358func (this *RunAsUserStrategyOptions) String() string {
4359	if this == nil {
4360		return "nil"
4361	}
4362	s := strings.Join([]string{`&RunAsUserStrategyOptions{`,
4363		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4364		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4365		`}`,
4366	}, "")
4367	return s
4368}
4369func (this *RuntimeClassStrategyOptions) String() string {
4370	if this == nil {
4371		return "nil"
4372	}
4373	s := strings.Join([]string{`&RuntimeClassStrategyOptions{`,
4374		`AllowedRuntimeClassNames:` + fmt.Sprintf("%v", this.AllowedRuntimeClassNames) + `,`,
4375		`DefaultRuntimeClassName:` + valueToStringGenerated(this.DefaultRuntimeClassName) + `,`,
4376		`}`,
4377	}, "")
4378	return s
4379}
4380func (this *SELinuxStrategyOptions) String() string {
4381	if this == nil {
4382		return "nil"
4383	}
4384	s := strings.Join([]string{`&SELinuxStrategyOptions{`,
4385		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4386		`SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`,
4387		`}`,
4388	}, "")
4389	return s
4390}
4391func (this *Scale) String() string {
4392	if this == nil {
4393		return "nil"
4394	}
4395	s := strings.Join([]string{`&Scale{`,
4396		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4397		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
4398		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
4399		`}`,
4400	}, "")
4401	return s
4402}
4403func (this *ScaleSpec) String() string {
4404	if this == nil {
4405		return "nil"
4406	}
4407	s := strings.Join([]string{`&ScaleSpec{`,
4408		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4409		`}`,
4410	}, "")
4411	return s
4412}
4413func (this *ScaleStatus) String() string {
4414	if this == nil {
4415		return "nil"
4416	}
4417	keysForSelector := make([]string, 0, len(this.Selector))
4418	for k := range this.Selector {
4419		keysForSelector = append(keysForSelector, k)
4420	}
4421	github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
4422	mapStringForSelector := "map[string]string{"
4423	for _, k := range keysForSelector {
4424		mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
4425	}
4426	mapStringForSelector += "}"
4427	s := strings.Join([]string{`&ScaleStatus{`,
4428		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4429		`Selector:` + mapStringForSelector + `,`,
4430		`TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
4431		`}`,
4432	}, "")
4433	return s
4434}
4435func (this *SupplementalGroupsStrategyOptions) String() string {
4436	if this == nil {
4437		return "nil"
4438	}
4439	s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`,
4440		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4441		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4442		`}`,
4443	}, "")
4444	return s
4445}
4446func valueToStringGenerated(v interface{}) string {
4447	rv := reflect.ValueOf(v)
4448	if rv.IsNil() {
4449		return "nil"
4450	}
4451	pv := reflect.Indirect(rv).Interface()
4452	return fmt.Sprintf("*%v", pv)
4453}
4454func (m *AllowedCSIDriver) Unmarshal(dAtA []byte) error {
4455	l := len(dAtA)
4456	iNdEx := 0
4457	for iNdEx < l {
4458		preIndex := iNdEx
4459		var wire uint64
4460		for shift := uint(0); ; shift += 7 {
4461			if shift >= 64 {
4462				return ErrIntOverflowGenerated
4463			}
4464			if iNdEx >= l {
4465				return io.ErrUnexpectedEOF
4466			}
4467			b := dAtA[iNdEx]
4468			iNdEx++
4469			wire |= (uint64(b) & 0x7F) << shift
4470			if b < 0x80 {
4471				break
4472			}
4473		}
4474		fieldNum := int32(wire >> 3)
4475		wireType := int(wire & 0x7)
4476		if wireType == 4 {
4477			return fmt.Errorf("proto: AllowedCSIDriver: wiretype end group for non-group")
4478		}
4479		if fieldNum <= 0 {
4480			return fmt.Errorf("proto: AllowedCSIDriver: illegal tag %d (wire type %d)", fieldNum, wire)
4481		}
4482		switch fieldNum {
4483		case 1:
4484			if wireType != 2 {
4485				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4486			}
4487			var stringLen uint64
4488			for shift := uint(0); ; shift += 7 {
4489				if shift >= 64 {
4490					return ErrIntOverflowGenerated
4491				}
4492				if iNdEx >= l {
4493					return io.ErrUnexpectedEOF
4494				}
4495				b := dAtA[iNdEx]
4496				iNdEx++
4497				stringLen |= (uint64(b) & 0x7F) << shift
4498				if b < 0x80 {
4499					break
4500				}
4501			}
4502			intStringLen := int(stringLen)
4503			if intStringLen < 0 {
4504				return ErrInvalidLengthGenerated
4505			}
4506			postIndex := iNdEx + intStringLen
4507			if postIndex > l {
4508				return io.ErrUnexpectedEOF
4509			}
4510			m.Name = string(dAtA[iNdEx:postIndex])
4511			iNdEx = postIndex
4512		default:
4513			iNdEx = preIndex
4514			skippy, err := skipGenerated(dAtA[iNdEx:])
4515			if err != nil {
4516				return err
4517			}
4518			if skippy < 0 {
4519				return ErrInvalidLengthGenerated
4520			}
4521			if (iNdEx + skippy) > l {
4522				return io.ErrUnexpectedEOF
4523			}
4524			iNdEx += skippy
4525		}
4526	}
4527
4528	if iNdEx > l {
4529		return io.ErrUnexpectedEOF
4530	}
4531	return nil
4532}
4533func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error {
4534	l := len(dAtA)
4535	iNdEx := 0
4536	for iNdEx < l {
4537		preIndex := iNdEx
4538		var wire uint64
4539		for shift := uint(0); ; shift += 7 {
4540			if shift >= 64 {
4541				return ErrIntOverflowGenerated
4542			}
4543			if iNdEx >= l {
4544				return io.ErrUnexpectedEOF
4545			}
4546			b := dAtA[iNdEx]
4547			iNdEx++
4548			wire |= (uint64(b) & 0x7F) << shift
4549			if b < 0x80 {
4550				break
4551			}
4552		}
4553		fieldNum := int32(wire >> 3)
4554		wireType := int(wire & 0x7)
4555		if wireType == 4 {
4556			return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group")
4557		}
4558		if fieldNum <= 0 {
4559			return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire)
4560		}
4561		switch fieldNum {
4562		case 1:
4563			if wireType != 2 {
4564				return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
4565			}
4566			var stringLen uint64
4567			for shift := uint(0); ; shift += 7 {
4568				if shift >= 64 {
4569					return ErrIntOverflowGenerated
4570				}
4571				if iNdEx >= l {
4572					return io.ErrUnexpectedEOF
4573				}
4574				b := dAtA[iNdEx]
4575				iNdEx++
4576				stringLen |= (uint64(b) & 0x7F) << shift
4577				if b < 0x80 {
4578					break
4579				}
4580			}
4581			intStringLen := int(stringLen)
4582			if intStringLen < 0 {
4583				return ErrInvalidLengthGenerated
4584			}
4585			postIndex := iNdEx + intStringLen
4586			if postIndex > l {
4587				return io.ErrUnexpectedEOF
4588			}
4589			m.Driver = string(dAtA[iNdEx:postIndex])
4590			iNdEx = postIndex
4591		default:
4592			iNdEx = preIndex
4593			skippy, err := skipGenerated(dAtA[iNdEx:])
4594			if err != nil {
4595				return err
4596			}
4597			if skippy < 0 {
4598				return ErrInvalidLengthGenerated
4599			}
4600			if (iNdEx + skippy) > l {
4601				return io.ErrUnexpectedEOF
4602			}
4603			iNdEx += skippy
4604		}
4605	}
4606
4607	if iNdEx > l {
4608		return io.ErrUnexpectedEOF
4609	}
4610	return nil
4611}
4612func (m *AllowedHostPath) Unmarshal(dAtA []byte) error {
4613	l := len(dAtA)
4614	iNdEx := 0
4615	for iNdEx < l {
4616		preIndex := iNdEx
4617		var wire uint64
4618		for shift := uint(0); ; shift += 7 {
4619			if shift >= 64 {
4620				return ErrIntOverflowGenerated
4621			}
4622			if iNdEx >= l {
4623				return io.ErrUnexpectedEOF
4624			}
4625			b := dAtA[iNdEx]
4626			iNdEx++
4627			wire |= (uint64(b) & 0x7F) << shift
4628			if b < 0x80 {
4629				break
4630			}
4631		}
4632		fieldNum := int32(wire >> 3)
4633		wireType := int(wire & 0x7)
4634		if wireType == 4 {
4635			return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group")
4636		}
4637		if fieldNum <= 0 {
4638			return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire)
4639		}
4640		switch fieldNum {
4641		case 1:
4642			if wireType != 2 {
4643				return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)
4644			}
4645			var stringLen uint64
4646			for shift := uint(0); ; shift += 7 {
4647				if shift >= 64 {
4648					return ErrIntOverflowGenerated
4649				}
4650				if iNdEx >= l {
4651					return io.ErrUnexpectedEOF
4652				}
4653				b := dAtA[iNdEx]
4654				iNdEx++
4655				stringLen |= (uint64(b) & 0x7F) << shift
4656				if b < 0x80 {
4657					break
4658				}
4659			}
4660			intStringLen := int(stringLen)
4661			if intStringLen < 0 {
4662				return ErrInvalidLengthGenerated
4663			}
4664			postIndex := iNdEx + intStringLen
4665			if postIndex > l {
4666				return io.ErrUnexpectedEOF
4667			}
4668			m.PathPrefix = string(dAtA[iNdEx:postIndex])
4669			iNdEx = postIndex
4670		case 2:
4671			if wireType != 0 {
4672				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
4673			}
4674			var v int
4675			for shift := uint(0); ; shift += 7 {
4676				if shift >= 64 {
4677					return ErrIntOverflowGenerated
4678				}
4679				if iNdEx >= l {
4680					return io.ErrUnexpectedEOF
4681				}
4682				b := dAtA[iNdEx]
4683				iNdEx++
4684				v |= (int(b) & 0x7F) << shift
4685				if b < 0x80 {
4686					break
4687				}
4688			}
4689			m.ReadOnly = bool(v != 0)
4690		default:
4691			iNdEx = preIndex
4692			skippy, err := skipGenerated(dAtA[iNdEx:])
4693			if err != nil {
4694				return err
4695			}
4696			if skippy < 0 {
4697				return ErrInvalidLengthGenerated
4698			}
4699			if (iNdEx + skippy) > l {
4700				return io.ErrUnexpectedEOF
4701			}
4702			iNdEx += skippy
4703		}
4704	}
4705
4706	if iNdEx > l {
4707		return io.ErrUnexpectedEOF
4708	}
4709	return nil
4710}
4711func (m *DaemonSet) Unmarshal(dAtA []byte) error {
4712	l := len(dAtA)
4713	iNdEx := 0
4714	for iNdEx < l {
4715		preIndex := iNdEx
4716		var wire uint64
4717		for shift := uint(0); ; shift += 7 {
4718			if shift >= 64 {
4719				return ErrIntOverflowGenerated
4720			}
4721			if iNdEx >= l {
4722				return io.ErrUnexpectedEOF
4723			}
4724			b := dAtA[iNdEx]
4725			iNdEx++
4726			wire |= (uint64(b) & 0x7F) << shift
4727			if b < 0x80 {
4728				break
4729			}
4730		}
4731		fieldNum := int32(wire >> 3)
4732		wireType := int(wire & 0x7)
4733		if wireType == 4 {
4734			return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
4735		}
4736		if fieldNum <= 0 {
4737			return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
4738		}
4739		switch fieldNum {
4740		case 1:
4741			if wireType != 2 {
4742				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4743			}
4744			var msglen int
4745			for shift := uint(0); ; shift += 7 {
4746				if shift >= 64 {
4747					return ErrIntOverflowGenerated
4748				}
4749				if iNdEx >= l {
4750					return io.ErrUnexpectedEOF
4751				}
4752				b := dAtA[iNdEx]
4753				iNdEx++
4754				msglen |= (int(b) & 0x7F) << shift
4755				if b < 0x80 {
4756					break
4757				}
4758			}
4759			if msglen < 0 {
4760				return ErrInvalidLengthGenerated
4761			}
4762			postIndex := iNdEx + msglen
4763			if postIndex > l {
4764				return io.ErrUnexpectedEOF
4765			}
4766			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4767				return err
4768			}
4769			iNdEx = postIndex
4770		case 2:
4771			if wireType != 2 {
4772				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4773			}
4774			var msglen int
4775			for shift := uint(0); ; shift += 7 {
4776				if shift >= 64 {
4777					return ErrIntOverflowGenerated
4778				}
4779				if iNdEx >= l {
4780					return io.ErrUnexpectedEOF
4781				}
4782				b := dAtA[iNdEx]
4783				iNdEx++
4784				msglen |= (int(b) & 0x7F) << shift
4785				if b < 0x80 {
4786					break
4787				}
4788			}
4789			if msglen < 0 {
4790				return ErrInvalidLengthGenerated
4791			}
4792			postIndex := iNdEx + msglen
4793			if postIndex > l {
4794				return io.ErrUnexpectedEOF
4795			}
4796			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4797				return err
4798			}
4799			iNdEx = postIndex
4800		case 3:
4801			if wireType != 2 {
4802				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4803			}
4804			var msglen int
4805			for shift := uint(0); ; shift += 7 {
4806				if shift >= 64 {
4807					return ErrIntOverflowGenerated
4808				}
4809				if iNdEx >= l {
4810					return io.ErrUnexpectedEOF
4811				}
4812				b := dAtA[iNdEx]
4813				iNdEx++
4814				msglen |= (int(b) & 0x7F) << shift
4815				if b < 0x80 {
4816					break
4817				}
4818			}
4819			if msglen < 0 {
4820				return ErrInvalidLengthGenerated
4821			}
4822			postIndex := iNdEx + msglen
4823			if postIndex > l {
4824				return io.ErrUnexpectedEOF
4825			}
4826			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4827				return err
4828			}
4829			iNdEx = postIndex
4830		default:
4831			iNdEx = preIndex
4832			skippy, err := skipGenerated(dAtA[iNdEx:])
4833			if err != nil {
4834				return err
4835			}
4836			if skippy < 0 {
4837				return ErrInvalidLengthGenerated
4838			}
4839			if (iNdEx + skippy) > l {
4840				return io.ErrUnexpectedEOF
4841			}
4842			iNdEx += skippy
4843		}
4844	}
4845
4846	if iNdEx > l {
4847		return io.ErrUnexpectedEOF
4848	}
4849	return nil
4850}
4851func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
4852	l := len(dAtA)
4853	iNdEx := 0
4854	for iNdEx < l {
4855		preIndex := iNdEx
4856		var wire uint64
4857		for shift := uint(0); ; shift += 7 {
4858			if shift >= 64 {
4859				return ErrIntOverflowGenerated
4860			}
4861			if iNdEx >= l {
4862				return io.ErrUnexpectedEOF
4863			}
4864			b := dAtA[iNdEx]
4865			iNdEx++
4866			wire |= (uint64(b) & 0x7F) << shift
4867			if b < 0x80 {
4868				break
4869			}
4870		}
4871		fieldNum := int32(wire >> 3)
4872		wireType := int(wire & 0x7)
4873		if wireType == 4 {
4874			return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
4875		}
4876		if fieldNum <= 0 {
4877			return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4878		}
4879		switch fieldNum {
4880		case 1:
4881			if wireType != 2 {
4882				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4883			}
4884			var stringLen uint64
4885			for shift := uint(0); ; shift += 7 {
4886				if shift >= 64 {
4887					return ErrIntOverflowGenerated
4888				}
4889				if iNdEx >= l {
4890					return io.ErrUnexpectedEOF
4891				}
4892				b := dAtA[iNdEx]
4893				iNdEx++
4894				stringLen |= (uint64(b) & 0x7F) << shift
4895				if b < 0x80 {
4896					break
4897				}
4898			}
4899			intStringLen := int(stringLen)
4900			if intStringLen < 0 {
4901				return ErrInvalidLengthGenerated
4902			}
4903			postIndex := iNdEx + intStringLen
4904			if postIndex > l {
4905				return io.ErrUnexpectedEOF
4906			}
4907			m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
4908			iNdEx = postIndex
4909		case 2:
4910			if wireType != 2 {
4911				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4912			}
4913			var stringLen uint64
4914			for shift := uint(0); ; shift += 7 {
4915				if shift >= 64 {
4916					return ErrIntOverflowGenerated
4917				}
4918				if iNdEx >= l {
4919					return io.ErrUnexpectedEOF
4920				}
4921				b := dAtA[iNdEx]
4922				iNdEx++
4923				stringLen |= (uint64(b) & 0x7F) << shift
4924				if b < 0x80 {
4925					break
4926				}
4927			}
4928			intStringLen := int(stringLen)
4929			if intStringLen < 0 {
4930				return ErrInvalidLengthGenerated
4931			}
4932			postIndex := iNdEx + intStringLen
4933			if postIndex > l {
4934				return io.ErrUnexpectedEOF
4935			}
4936			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4937			iNdEx = postIndex
4938		case 3:
4939			if wireType != 2 {
4940				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4941			}
4942			var msglen int
4943			for shift := uint(0); ; shift += 7 {
4944				if shift >= 64 {
4945					return ErrIntOverflowGenerated
4946				}
4947				if iNdEx >= l {
4948					return io.ErrUnexpectedEOF
4949				}
4950				b := dAtA[iNdEx]
4951				iNdEx++
4952				msglen |= (int(b) & 0x7F) << shift
4953				if b < 0x80 {
4954					break
4955				}
4956			}
4957			if msglen < 0 {
4958				return ErrInvalidLengthGenerated
4959			}
4960			postIndex := iNdEx + msglen
4961			if postIndex > l {
4962				return io.ErrUnexpectedEOF
4963			}
4964			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4965				return err
4966			}
4967			iNdEx = postIndex
4968		case 4:
4969			if wireType != 2 {
4970				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4971			}
4972			var stringLen uint64
4973			for shift := uint(0); ; shift += 7 {
4974				if shift >= 64 {
4975					return ErrIntOverflowGenerated
4976				}
4977				if iNdEx >= l {
4978					return io.ErrUnexpectedEOF
4979				}
4980				b := dAtA[iNdEx]
4981				iNdEx++
4982				stringLen |= (uint64(b) & 0x7F) << shift
4983				if b < 0x80 {
4984					break
4985				}
4986			}
4987			intStringLen := int(stringLen)
4988			if intStringLen < 0 {
4989				return ErrInvalidLengthGenerated
4990			}
4991			postIndex := iNdEx + intStringLen
4992			if postIndex > l {
4993				return io.ErrUnexpectedEOF
4994			}
4995			m.Reason = string(dAtA[iNdEx:postIndex])
4996			iNdEx = postIndex
4997		case 5:
4998			if wireType != 2 {
4999				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5000			}
5001			var stringLen uint64
5002			for shift := uint(0); ; shift += 7 {
5003				if shift >= 64 {
5004					return ErrIntOverflowGenerated
5005				}
5006				if iNdEx >= l {
5007					return io.ErrUnexpectedEOF
5008				}
5009				b := dAtA[iNdEx]
5010				iNdEx++
5011				stringLen |= (uint64(b) & 0x7F) << shift
5012				if b < 0x80 {
5013					break
5014				}
5015			}
5016			intStringLen := int(stringLen)
5017			if intStringLen < 0 {
5018				return ErrInvalidLengthGenerated
5019			}
5020			postIndex := iNdEx + intStringLen
5021			if postIndex > l {
5022				return io.ErrUnexpectedEOF
5023			}
5024			m.Message = string(dAtA[iNdEx:postIndex])
5025			iNdEx = postIndex
5026		default:
5027			iNdEx = preIndex
5028			skippy, err := skipGenerated(dAtA[iNdEx:])
5029			if err != nil {
5030				return err
5031			}
5032			if skippy < 0 {
5033				return ErrInvalidLengthGenerated
5034			}
5035			if (iNdEx + skippy) > l {
5036				return io.ErrUnexpectedEOF
5037			}
5038			iNdEx += skippy
5039		}
5040	}
5041
5042	if iNdEx > l {
5043		return io.ErrUnexpectedEOF
5044	}
5045	return nil
5046}
5047func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
5048	l := len(dAtA)
5049	iNdEx := 0
5050	for iNdEx < l {
5051		preIndex := iNdEx
5052		var wire uint64
5053		for shift := uint(0); ; shift += 7 {
5054			if shift >= 64 {
5055				return ErrIntOverflowGenerated
5056			}
5057			if iNdEx >= l {
5058				return io.ErrUnexpectedEOF
5059			}
5060			b := dAtA[iNdEx]
5061			iNdEx++
5062			wire |= (uint64(b) & 0x7F) << shift
5063			if b < 0x80 {
5064				break
5065			}
5066		}
5067		fieldNum := int32(wire >> 3)
5068		wireType := int(wire & 0x7)
5069		if wireType == 4 {
5070			return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
5071		}
5072		if fieldNum <= 0 {
5073			return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
5074		}
5075		switch fieldNum {
5076		case 1:
5077			if wireType != 2 {
5078				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5079			}
5080			var msglen int
5081			for shift := uint(0); ; shift += 7 {
5082				if shift >= 64 {
5083					return ErrIntOverflowGenerated
5084				}
5085				if iNdEx >= l {
5086					return io.ErrUnexpectedEOF
5087				}
5088				b := dAtA[iNdEx]
5089				iNdEx++
5090				msglen |= (int(b) & 0x7F) << shift
5091				if b < 0x80 {
5092					break
5093				}
5094			}
5095			if msglen < 0 {
5096				return ErrInvalidLengthGenerated
5097			}
5098			postIndex := iNdEx + msglen
5099			if postIndex > l {
5100				return io.ErrUnexpectedEOF
5101			}
5102			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5103				return err
5104			}
5105			iNdEx = postIndex
5106		case 2:
5107			if wireType != 2 {
5108				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5109			}
5110			var msglen int
5111			for shift := uint(0); ; shift += 7 {
5112				if shift >= 64 {
5113					return ErrIntOverflowGenerated
5114				}
5115				if iNdEx >= l {
5116					return io.ErrUnexpectedEOF
5117				}
5118				b := dAtA[iNdEx]
5119				iNdEx++
5120				msglen |= (int(b) & 0x7F) << shift
5121				if b < 0x80 {
5122					break
5123				}
5124			}
5125			if msglen < 0 {
5126				return ErrInvalidLengthGenerated
5127			}
5128			postIndex := iNdEx + msglen
5129			if postIndex > l {
5130				return io.ErrUnexpectedEOF
5131			}
5132			m.Items = append(m.Items, DaemonSet{})
5133			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5134				return err
5135			}
5136			iNdEx = postIndex
5137		default:
5138			iNdEx = preIndex
5139			skippy, err := skipGenerated(dAtA[iNdEx:])
5140			if err != nil {
5141				return err
5142			}
5143			if skippy < 0 {
5144				return ErrInvalidLengthGenerated
5145			}
5146			if (iNdEx + skippy) > l {
5147				return io.ErrUnexpectedEOF
5148			}
5149			iNdEx += skippy
5150		}
5151	}
5152
5153	if iNdEx > l {
5154		return io.ErrUnexpectedEOF
5155	}
5156	return nil
5157}
5158func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
5159	l := len(dAtA)
5160	iNdEx := 0
5161	for iNdEx < l {
5162		preIndex := iNdEx
5163		var wire uint64
5164		for shift := uint(0); ; shift += 7 {
5165			if shift >= 64 {
5166				return ErrIntOverflowGenerated
5167			}
5168			if iNdEx >= l {
5169				return io.ErrUnexpectedEOF
5170			}
5171			b := dAtA[iNdEx]
5172			iNdEx++
5173			wire |= (uint64(b) & 0x7F) << shift
5174			if b < 0x80 {
5175				break
5176			}
5177		}
5178		fieldNum := int32(wire >> 3)
5179		wireType := int(wire & 0x7)
5180		if wireType == 4 {
5181			return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
5182		}
5183		if fieldNum <= 0 {
5184			return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5185		}
5186		switch fieldNum {
5187		case 1:
5188			if wireType != 2 {
5189				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5190			}
5191			var msglen int
5192			for shift := uint(0); ; shift += 7 {
5193				if shift >= 64 {
5194					return ErrIntOverflowGenerated
5195				}
5196				if iNdEx >= l {
5197					return io.ErrUnexpectedEOF
5198				}
5199				b := dAtA[iNdEx]
5200				iNdEx++
5201				msglen |= (int(b) & 0x7F) << shift
5202				if b < 0x80 {
5203					break
5204				}
5205			}
5206			if msglen < 0 {
5207				return ErrInvalidLengthGenerated
5208			}
5209			postIndex := iNdEx + msglen
5210			if postIndex > l {
5211				return io.ErrUnexpectedEOF
5212			}
5213			if m.Selector == nil {
5214				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
5215			}
5216			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5217				return err
5218			}
5219			iNdEx = postIndex
5220		case 2:
5221			if wireType != 2 {
5222				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
5223			}
5224			var msglen int
5225			for shift := uint(0); ; shift += 7 {
5226				if shift >= 64 {
5227					return ErrIntOverflowGenerated
5228				}
5229				if iNdEx >= l {
5230					return io.ErrUnexpectedEOF
5231				}
5232				b := dAtA[iNdEx]
5233				iNdEx++
5234				msglen |= (int(b) & 0x7F) << shift
5235				if b < 0x80 {
5236					break
5237				}
5238			}
5239			if msglen < 0 {
5240				return ErrInvalidLengthGenerated
5241			}
5242			postIndex := iNdEx + msglen
5243			if postIndex > l {
5244				return io.ErrUnexpectedEOF
5245			}
5246			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5247				return err
5248			}
5249			iNdEx = postIndex
5250		case 3:
5251			if wireType != 2 {
5252				return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
5253			}
5254			var msglen int
5255			for shift := uint(0); ; shift += 7 {
5256				if shift >= 64 {
5257					return ErrIntOverflowGenerated
5258				}
5259				if iNdEx >= l {
5260					return io.ErrUnexpectedEOF
5261				}
5262				b := dAtA[iNdEx]
5263				iNdEx++
5264				msglen |= (int(b) & 0x7F) << shift
5265				if b < 0x80 {
5266					break
5267				}
5268			}
5269			if msglen < 0 {
5270				return ErrInvalidLengthGenerated
5271			}
5272			postIndex := iNdEx + msglen
5273			if postIndex > l {
5274				return io.ErrUnexpectedEOF
5275			}
5276			if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5277				return err
5278			}
5279			iNdEx = postIndex
5280		case 4:
5281			if wireType != 0 {
5282				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
5283			}
5284			m.MinReadySeconds = 0
5285			for shift := uint(0); ; shift += 7 {
5286				if shift >= 64 {
5287					return ErrIntOverflowGenerated
5288				}
5289				if iNdEx >= l {
5290					return io.ErrUnexpectedEOF
5291				}
5292				b := dAtA[iNdEx]
5293				iNdEx++
5294				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
5295				if b < 0x80 {
5296					break
5297				}
5298			}
5299		case 5:
5300			if wireType != 0 {
5301				return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType)
5302			}
5303			m.TemplateGeneration = 0
5304			for shift := uint(0); ; shift += 7 {
5305				if shift >= 64 {
5306					return ErrIntOverflowGenerated
5307				}
5308				if iNdEx >= l {
5309					return io.ErrUnexpectedEOF
5310				}
5311				b := dAtA[iNdEx]
5312				iNdEx++
5313				m.TemplateGeneration |= (int64(b) & 0x7F) << shift
5314				if b < 0x80 {
5315					break
5316				}
5317			}
5318		case 6:
5319			if wireType != 0 {
5320				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
5321			}
5322			var v int32
5323			for shift := uint(0); ; shift += 7 {
5324				if shift >= 64 {
5325					return ErrIntOverflowGenerated
5326				}
5327				if iNdEx >= l {
5328					return io.ErrUnexpectedEOF
5329				}
5330				b := dAtA[iNdEx]
5331				iNdEx++
5332				v |= (int32(b) & 0x7F) << shift
5333				if b < 0x80 {
5334					break
5335				}
5336			}
5337			m.RevisionHistoryLimit = &v
5338		default:
5339			iNdEx = preIndex
5340			skippy, err := skipGenerated(dAtA[iNdEx:])
5341			if err != nil {
5342				return err
5343			}
5344			if skippy < 0 {
5345				return ErrInvalidLengthGenerated
5346			}
5347			if (iNdEx + skippy) > l {
5348				return io.ErrUnexpectedEOF
5349			}
5350			iNdEx += skippy
5351		}
5352	}
5353
5354	if iNdEx > l {
5355		return io.ErrUnexpectedEOF
5356	}
5357	return nil
5358}
5359func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
5360	l := len(dAtA)
5361	iNdEx := 0
5362	for iNdEx < l {
5363		preIndex := iNdEx
5364		var wire uint64
5365		for shift := uint(0); ; shift += 7 {
5366			if shift >= 64 {
5367				return ErrIntOverflowGenerated
5368			}
5369			if iNdEx >= l {
5370				return io.ErrUnexpectedEOF
5371			}
5372			b := dAtA[iNdEx]
5373			iNdEx++
5374			wire |= (uint64(b) & 0x7F) << shift
5375			if b < 0x80 {
5376				break
5377			}
5378		}
5379		fieldNum := int32(wire >> 3)
5380		wireType := int(wire & 0x7)
5381		if wireType == 4 {
5382			return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
5383		}
5384		if fieldNum <= 0 {
5385			return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5386		}
5387		switch fieldNum {
5388		case 1:
5389			if wireType != 0 {
5390				return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
5391			}
5392			m.CurrentNumberScheduled = 0
5393			for shift := uint(0); ; shift += 7 {
5394				if shift >= 64 {
5395					return ErrIntOverflowGenerated
5396				}
5397				if iNdEx >= l {
5398					return io.ErrUnexpectedEOF
5399				}
5400				b := dAtA[iNdEx]
5401				iNdEx++
5402				m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift
5403				if b < 0x80 {
5404					break
5405				}
5406			}
5407		case 2:
5408			if wireType != 0 {
5409				return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
5410			}
5411			m.NumberMisscheduled = 0
5412			for shift := uint(0); ; shift += 7 {
5413				if shift >= 64 {
5414					return ErrIntOverflowGenerated
5415				}
5416				if iNdEx >= l {
5417					return io.ErrUnexpectedEOF
5418				}
5419				b := dAtA[iNdEx]
5420				iNdEx++
5421				m.NumberMisscheduled |= (int32(b) & 0x7F) << shift
5422				if b < 0x80 {
5423					break
5424				}
5425			}
5426		case 3:
5427			if wireType != 0 {
5428				return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
5429			}
5430			m.DesiredNumberScheduled = 0
5431			for shift := uint(0); ; shift += 7 {
5432				if shift >= 64 {
5433					return ErrIntOverflowGenerated
5434				}
5435				if iNdEx >= l {
5436					return io.ErrUnexpectedEOF
5437				}
5438				b := dAtA[iNdEx]
5439				iNdEx++
5440				m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift
5441				if b < 0x80 {
5442					break
5443				}
5444			}
5445		case 4:
5446			if wireType != 0 {
5447				return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
5448			}
5449			m.NumberReady = 0
5450			for shift := uint(0); ; shift += 7 {
5451				if shift >= 64 {
5452					return ErrIntOverflowGenerated
5453				}
5454				if iNdEx >= l {
5455					return io.ErrUnexpectedEOF
5456				}
5457				b := dAtA[iNdEx]
5458				iNdEx++
5459				m.NumberReady |= (int32(b) & 0x7F) << shift
5460				if b < 0x80 {
5461					break
5462				}
5463			}
5464		case 5:
5465			if wireType != 0 {
5466				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
5467			}
5468			m.ObservedGeneration = 0
5469			for shift := uint(0); ; shift += 7 {
5470				if shift >= 64 {
5471					return ErrIntOverflowGenerated
5472				}
5473				if iNdEx >= l {
5474					return io.ErrUnexpectedEOF
5475				}
5476				b := dAtA[iNdEx]
5477				iNdEx++
5478				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
5479				if b < 0x80 {
5480					break
5481				}
5482			}
5483		case 6:
5484			if wireType != 0 {
5485				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
5486			}
5487			m.UpdatedNumberScheduled = 0
5488			for shift := uint(0); ; shift += 7 {
5489				if shift >= 64 {
5490					return ErrIntOverflowGenerated
5491				}
5492				if iNdEx >= l {
5493					return io.ErrUnexpectedEOF
5494				}
5495				b := dAtA[iNdEx]
5496				iNdEx++
5497				m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift
5498				if b < 0x80 {
5499					break
5500				}
5501			}
5502		case 7:
5503			if wireType != 0 {
5504				return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
5505			}
5506			m.NumberAvailable = 0
5507			for shift := uint(0); ; shift += 7 {
5508				if shift >= 64 {
5509					return ErrIntOverflowGenerated
5510				}
5511				if iNdEx >= l {
5512					return io.ErrUnexpectedEOF
5513				}
5514				b := dAtA[iNdEx]
5515				iNdEx++
5516				m.NumberAvailable |= (int32(b) & 0x7F) << shift
5517				if b < 0x80 {
5518					break
5519				}
5520			}
5521		case 8:
5522			if wireType != 0 {
5523				return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
5524			}
5525			m.NumberUnavailable = 0
5526			for shift := uint(0); ; shift += 7 {
5527				if shift >= 64 {
5528					return ErrIntOverflowGenerated
5529				}
5530				if iNdEx >= l {
5531					return io.ErrUnexpectedEOF
5532				}
5533				b := dAtA[iNdEx]
5534				iNdEx++
5535				m.NumberUnavailable |= (int32(b) & 0x7F) << shift
5536				if b < 0x80 {
5537					break
5538				}
5539			}
5540		case 9:
5541			if wireType != 0 {
5542				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
5543			}
5544			var v int32
5545			for shift := uint(0); ; shift += 7 {
5546				if shift >= 64 {
5547					return ErrIntOverflowGenerated
5548				}
5549				if iNdEx >= l {
5550					return io.ErrUnexpectedEOF
5551				}
5552				b := dAtA[iNdEx]
5553				iNdEx++
5554				v |= (int32(b) & 0x7F) << shift
5555				if b < 0x80 {
5556					break
5557				}
5558			}
5559			m.CollisionCount = &v
5560		case 10:
5561			if wireType != 2 {
5562				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5563			}
5564			var msglen int
5565			for shift := uint(0); ; shift += 7 {
5566				if shift >= 64 {
5567					return ErrIntOverflowGenerated
5568				}
5569				if iNdEx >= l {
5570					return io.ErrUnexpectedEOF
5571				}
5572				b := dAtA[iNdEx]
5573				iNdEx++
5574				msglen |= (int(b) & 0x7F) << shift
5575				if b < 0x80 {
5576					break
5577				}
5578			}
5579			if msglen < 0 {
5580				return ErrInvalidLengthGenerated
5581			}
5582			postIndex := iNdEx + msglen
5583			if postIndex > l {
5584				return io.ErrUnexpectedEOF
5585			}
5586			m.Conditions = append(m.Conditions, DaemonSetCondition{})
5587			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5588				return err
5589			}
5590			iNdEx = postIndex
5591		default:
5592			iNdEx = preIndex
5593			skippy, err := skipGenerated(dAtA[iNdEx:])
5594			if err != nil {
5595				return err
5596			}
5597			if skippy < 0 {
5598				return ErrInvalidLengthGenerated
5599			}
5600			if (iNdEx + skippy) > l {
5601				return io.ErrUnexpectedEOF
5602			}
5603			iNdEx += skippy
5604		}
5605	}
5606
5607	if iNdEx > l {
5608		return io.ErrUnexpectedEOF
5609	}
5610	return nil
5611}
5612func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
5613	l := len(dAtA)
5614	iNdEx := 0
5615	for iNdEx < l {
5616		preIndex := iNdEx
5617		var wire uint64
5618		for shift := uint(0); ; shift += 7 {
5619			if shift >= 64 {
5620				return ErrIntOverflowGenerated
5621			}
5622			if iNdEx >= l {
5623				return io.ErrUnexpectedEOF
5624			}
5625			b := dAtA[iNdEx]
5626			iNdEx++
5627			wire |= (uint64(b) & 0x7F) << shift
5628			if b < 0x80 {
5629				break
5630			}
5631		}
5632		fieldNum := int32(wire >> 3)
5633		wireType := int(wire & 0x7)
5634		if wireType == 4 {
5635			return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
5636		}
5637		if fieldNum <= 0 {
5638			return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
5639		}
5640		switch fieldNum {
5641		case 1:
5642			if wireType != 2 {
5643				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5644			}
5645			var stringLen uint64
5646			for shift := uint(0); ; shift += 7 {
5647				if shift >= 64 {
5648					return ErrIntOverflowGenerated
5649				}
5650				if iNdEx >= l {
5651					return io.ErrUnexpectedEOF
5652				}
5653				b := dAtA[iNdEx]
5654				iNdEx++
5655				stringLen |= (uint64(b) & 0x7F) << shift
5656				if b < 0x80 {
5657					break
5658				}
5659			}
5660			intStringLen := int(stringLen)
5661			if intStringLen < 0 {
5662				return ErrInvalidLengthGenerated
5663			}
5664			postIndex := iNdEx + intStringLen
5665			if postIndex > l {
5666				return io.ErrUnexpectedEOF
5667			}
5668			m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
5669			iNdEx = postIndex
5670		case 2:
5671			if wireType != 2 {
5672				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
5673			}
5674			var msglen int
5675			for shift := uint(0); ; shift += 7 {
5676				if shift >= 64 {
5677					return ErrIntOverflowGenerated
5678				}
5679				if iNdEx >= l {
5680					return io.ErrUnexpectedEOF
5681				}
5682				b := dAtA[iNdEx]
5683				iNdEx++
5684				msglen |= (int(b) & 0x7F) << shift
5685				if b < 0x80 {
5686					break
5687				}
5688			}
5689			if msglen < 0 {
5690				return ErrInvalidLengthGenerated
5691			}
5692			postIndex := iNdEx + msglen
5693			if postIndex > l {
5694				return io.ErrUnexpectedEOF
5695			}
5696			if m.RollingUpdate == nil {
5697				m.RollingUpdate = &RollingUpdateDaemonSet{}
5698			}
5699			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5700				return err
5701			}
5702			iNdEx = postIndex
5703		default:
5704			iNdEx = preIndex
5705			skippy, err := skipGenerated(dAtA[iNdEx:])
5706			if err != nil {
5707				return err
5708			}
5709			if skippy < 0 {
5710				return ErrInvalidLengthGenerated
5711			}
5712			if (iNdEx + skippy) > l {
5713				return io.ErrUnexpectedEOF
5714			}
5715			iNdEx += skippy
5716		}
5717	}
5718
5719	if iNdEx > l {
5720		return io.ErrUnexpectedEOF
5721	}
5722	return nil
5723}
5724func (m *Deployment) Unmarshal(dAtA []byte) error {
5725	l := len(dAtA)
5726	iNdEx := 0
5727	for iNdEx < l {
5728		preIndex := iNdEx
5729		var wire uint64
5730		for shift := uint(0); ; shift += 7 {
5731			if shift >= 64 {
5732				return ErrIntOverflowGenerated
5733			}
5734			if iNdEx >= l {
5735				return io.ErrUnexpectedEOF
5736			}
5737			b := dAtA[iNdEx]
5738			iNdEx++
5739			wire |= (uint64(b) & 0x7F) << shift
5740			if b < 0x80 {
5741				break
5742			}
5743		}
5744		fieldNum := int32(wire >> 3)
5745		wireType := int(wire & 0x7)
5746		if wireType == 4 {
5747			return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
5748		}
5749		if fieldNum <= 0 {
5750			return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
5751		}
5752		switch fieldNum {
5753		case 1:
5754			if wireType != 2 {
5755				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5756			}
5757			var msglen int
5758			for shift := uint(0); ; shift += 7 {
5759				if shift >= 64 {
5760					return ErrIntOverflowGenerated
5761				}
5762				if iNdEx >= l {
5763					return io.ErrUnexpectedEOF
5764				}
5765				b := dAtA[iNdEx]
5766				iNdEx++
5767				msglen |= (int(b) & 0x7F) << shift
5768				if b < 0x80 {
5769					break
5770				}
5771			}
5772			if msglen < 0 {
5773				return ErrInvalidLengthGenerated
5774			}
5775			postIndex := iNdEx + msglen
5776			if postIndex > l {
5777				return io.ErrUnexpectedEOF
5778			}
5779			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5780				return err
5781			}
5782			iNdEx = postIndex
5783		case 2:
5784			if wireType != 2 {
5785				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5786			}
5787			var msglen int
5788			for shift := uint(0); ; shift += 7 {
5789				if shift >= 64 {
5790					return ErrIntOverflowGenerated
5791				}
5792				if iNdEx >= l {
5793					return io.ErrUnexpectedEOF
5794				}
5795				b := dAtA[iNdEx]
5796				iNdEx++
5797				msglen |= (int(b) & 0x7F) << shift
5798				if b < 0x80 {
5799					break
5800				}
5801			}
5802			if msglen < 0 {
5803				return ErrInvalidLengthGenerated
5804			}
5805			postIndex := iNdEx + msglen
5806			if postIndex > l {
5807				return io.ErrUnexpectedEOF
5808			}
5809			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5810				return err
5811			}
5812			iNdEx = postIndex
5813		case 3:
5814			if wireType != 2 {
5815				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5816			}
5817			var msglen int
5818			for shift := uint(0); ; shift += 7 {
5819				if shift >= 64 {
5820					return ErrIntOverflowGenerated
5821				}
5822				if iNdEx >= l {
5823					return io.ErrUnexpectedEOF
5824				}
5825				b := dAtA[iNdEx]
5826				iNdEx++
5827				msglen |= (int(b) & 0x7F) << shift
5828				if b < 0x80 {
5829					break
5830				}
5831			}
5832			if msglen < 0 {
5833				return ErrInvalidLengthGenerated
5834			}
5835			postIndex := iNdEx + msglen
5836			if postIndex > l {
5837				return io.ErrUnexpectedEOF
5838			}
5839			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5840				return err
5841			}
5842			iNdEx = postIndex
5843		default:
5844			iNdEx = preIndex
5845			skippy, err := skipGenerated(dAtA[iNdEx:])
5846			if err != nil {
5847				return err
5848			}
5849			if skippy < 0 {
5850				return ErrInvalidLengthGenerated
5851			}
5852			if (iNdEx + skippy) > l {
5853				return io.ErrUnexpectedEOF
5854			}
5855			iNdEx += skippy
5856		}
5857	}
5858
5859	if iNdEx > l {
5860		return io.ErrUnexpectedEOF
5861	}
5862	return nil
5863}
5864func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
5865	l := len(dAtA)
5866	iNdEx := 0
5867	for iNdEx < l {
5868		preIndex := iNdEx
5869		var wire uint64
5870		for shift := uint(0); ; shift += 7 {
5871			if shift >= 64 {
5872				return ErrIntOverflowGenerated
5873			}
5874			if iNdEx >= l {
5875				return io.ErrUnexpectedEOF
5876			}
5877			b := dAtA[iNdEx]
5878			iNdEx++
5879			wire |= (uint64(b) & 0x7F) << shift
5880			if b < 0x80 {
5881				break
5882			}
5883		}
5884		fieldNum := int32(wire >> 3)
5885		wireType := int(wire & 0x7)
5886		if wireType == 4 {
5887			return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
5888		}
5889		if fieldNum <= 0 {
5890			return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5891		}
5892		switch fieldNum {
5893		case 1:
5894			if wireType != 2 {
5895				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5896			}
5897			var stringLen uint64
5898			for shift := uint(0); ; shift += 7 {
5899				if shift >= 64 {
5900					return ErrIntOverflowGenerated
5901				}
5902				if iNdEx >= l {
5903					return io.ErrUnexpectedEOF
5904				}
5905				b := dAtA[iNdEx]
5906				iNdEx++
5907				stringLen |= (uint64(b) & 0x7F) << shift
5908				if b < 0x80 {
5909					break
5910				}
5911			}
5912			intStringLen := int(stringLen)
5913			if intStringLen < 0 {
5914				return ErrInvalidLengthGenerated
5915			}
5916			postIndex := iNdEx + intStringLen
5917			if postIndex > l {
5918				return io.ErrUnexpectedEOF
5919			}
5920			m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
5921			iNdEx = postIndex
5922		case 2:
5923			if wireType != 2 {
5924				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5925			}
5926			var stringLen uint64
5927			for shift := uint(0); ; shift += 7 {
5928				if shift >= 64 {
5929					return ErrIntOverflowGenerated
5930				}
5931				if iNdEx >= l {
5932					return io.ErrUnexpectedEOF
5933				}
5934				b := dAtA[iNdEx]
5935				iNdEx++
5936				stringLen |= (uint64(b) & 0x7F) << shift
5937				if b < 0x80 {
5938					break
5939				}
5940			}
5941			intStringLen := int(stringLen)
5942			if intStringLen < 0 {
5943				return ErrInvalidLengthGenerated
5944			}
5945			postIndex := iNdEx + intStringLen
5946			if postIndex > l {
5947				return io.ErrUnexpectedEOF
5948			}
5949			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5950			iNdEx = postIndex
5951		case 4:
5952			if wireType != 2 {
5953				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5954			}
5955			var stringLen uint64
5956			for shift := uint(0); ; shift += 7 {
5957				if shift >= 64 {
5958					return ErrIntOverflowGenerated
5959				}
5960				if iNdEx >= l {
5961					return io.ErrUnexpectedEOF
5962				}
5963				b := dAtA[iNdEx]
5964				iNdEx++
5965				stringLen |= (uint64(b) & 0x7F) << shift
5966				if b < 0x80 {
5967					break
5968				}
5969			}
5970			intStringLen := int(stringLen)
5971			if intStringLen < 0 {
5972				return ErrInvalidLengthGenerated
5973			}
5974			postIndex := iNdEx + intStringLen
5975			if postIndex > l {
5976				return io.ErrUnexpectedEOF
5977			}
5978			m.Reason = string(dAtA[iNdEx:postIndex])
5979			iNdEx = postIndex
5980		case 5:
5981			if wireType != 2 {
5982				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5983			}
5984			var stringLen uint64
5985			for shift := uint(0); ; shift += 7 {
5986				if shift >= 64 {
5987					return ErrIntOverflowGenerated
5988				}
5989				if iNdEx >= l {
5990					return io.ErrUnexpectedEOF
5991				}
5992				b := dAtA[iNdEx]
5993				iNdEx++
5994				stringLen |= (uint64(b) & 0x7F) << shift
5995				if b < 0x80 {
5996					break
5997				}
5998			}
5999			intStringLen := int(stringLen)
6000			if intStringLen < 0 {
6001				return ErrInvalidLengthGenerated
6002			}
6003			postIndex := iNdEx + intStringLen
6004			if postIndex > l {
6005				return io.ErrUnexpectedEOF
6006			}
6007			m.Message = string(dAtA[iNdEx:postIndex])
6008			iNdEx = postIndex
6009		case 6:
6010			if wireType != 2 {
6011				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
6012			}
6013			var msglen int
6014			for shift := uint(0); ; shift += 7 {
6015				if shift >= 64 {
6016					return ErrIntOverflowGenerated
6017				}
6018				if iNdEx >= l {
6019					return io.ErrUnexpectedEOF
6020				}
6021				b := dAtA[iNdEx]
6022				iNdEx++
6023				msglen |= (int(b) & 0x7F) << shift
6024				if b < 0x80 {
6025					break
6026				}
6027			}
6028			if msglen < 0 {
6029				return ErrInvalidLengthGenerated
6030			}
6031			postIndex := iNdEx + msglen
6032			if postIndex > l {
6033				return io.ErrUnexpectedEOF
6034			}
6035			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6036				return err
6037			}
6038			iNdEx = postIndex
6039		case 7:
6040			if wireType != 2 {
6041				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
6042			}
6043			var msglen int
6044			for shift := uint(0); ; shift += 7 {
6045				if shift >= 64 {
6046					return ErrIntOverflowGenerated
6047				}
6048				if iNdEx >= l {
6049					return io.ErrUnexpectedEOF
6050				}
6051				b := dAtA[iNdEx]
6052				iNdEx++
6053				msglen |= (int(b) & 0x7F) << shift
6054				if b < 0x80 {
6055					break
6056				}
6057			}
6058			if msglen < 0 {
6059				return ErrInvalidLengthGenerated
6060			}
6061			postIndex := iNdEx + msglen
6062			if postIndex > l {
6063				return io.ErrUnexpectedEOF
6064			}
6065			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6066				return err
6067			}
6068			iNdEx = postIndex
6069		default:
6070			iNdEx = preIndex
6071			skippy, err := skipGenerated(dAtA[iNdEx:])
6072			if err != nil {
6073				return err
6074			}
6075			if skippy < 0 {
6076				return ErrInvalidLengthGenerated
6077			}
6078			if (iNdEx + skippy) > l {
6079				return io.ErrUnexpectedEOF
6080			}
6081			iNdEx += skippy
6082		}
6083	}
6084
6085	if iNdEx > l {
6086		return io.ErrUnexpectedEOF
6087	}
6088	return nil
6089}
6090func (m *DeploymentList) Unmarshal(dAtA []byte) error {
6091	l := len(dAtA)
6092	iNdEx := 0
6093	for iNdEx < l {
6094		preIndex := iNdEx
6095		var wire uint64
6096		for shift := uint(0); ; shift += 7 {
6097			if shift >= 64 {
6098				return ErrIntOverflowGenerated
6099			}
6100			if iNdEx >= l {
6101				return io.ErrUnexpectedEOF
6102			}
6103			b := dAtA[iNdEx]
6104			iNdEx++
6105			wire |= (uint64(b) & 0x7F) << shift
6106			if b < 0x80 {
6107				break
6108			}
6109		}
6110		fieldNum := int32(wire >> 3)
6111		wireType := int(wire & 0x7)
6112		if wireType == 4 {
6113			return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
6114		}
6115		if fieldNum <= 0 {
6116			return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
6117		}
6118		switch fieldNum {
6119		case 1:
6120			if wireType != 2 {
6121				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
6122			}
6123			var msglen int
6124			for shift := uint(0); ; shift += 7 {
6125				if shift >= 64 {
6126					return ErrIntOverflowGenerated
6127				}
6128				if iNdEx >= l {
6129					return io.ErrUnexpectedEOF
6130				}
6131				b := dAtA[iNdEx]
6132				iNdEx++
6133				msglen |= (int(b) & 0x7F) << shift
6134				if b < 0x80 {
6135					break
6136				}
6137			}
6138			if msglen < 0 {
6139				return ErrInvalidLengthGenerated
6140			}
6141			postIndex := iNdEx + msglen
6142			if postIndex > l {
6143				return io.ErrUnexpectedEOF
6144			}
6145			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6146				return err
6147			}
6148			iNdEx = postIndex
6149		case 2:
6150			if wireType != 2 {
6151				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
6152			}
6153			var msglen int
6154			for shift := uint(0); ; shift += 7 {
6155				if shift >= 64 {
6156					return ErrIntOverflowGenerated
6157				}
6158				if iNdEx >= l {
6159					return io.ErrUnexpectedEOF
6160				}
6161				b := dAtA[iNdEx]
6162				iNdEx++
6163				msglen |= (int(b) & 0x7F) << shift
6164				if b < 0x80 {
6165					break
6166				}
6167			}
6168			if msglen < 0 {
6169				return ErrInvalidLengthGenerated
6170			}
6171			postIndex := iNdEx + msglen
6172			if postIndex > l {
6173				return io.ErrUnexpectedEOF
6174			}
6175			m.Items = append(m.Items, Deployment{})
6176			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6177				return err
6178			}
6179			iNdEx = postIndex
6180		default:
6181			iNdEx = preIndex
6182			skippy, err := skipGenerated(dAtA[iNdEx:])
6183			if err != nil {
6184				return err
6185			}
6186			if skippy < 0 {
6187				return ErrInvalidLengthGenerated
6188			}
6189			if (iNdEx + skippy) > l {
6190				return io.ErrUnexpectedEOF
6191			}
6192			iNdEx += skippy
6193		}
6194	}
6195
6196	if iNdEx > l {
6197		return io.ErrUnexpectedEOF
6198	}
6199	return nil
6200}
6201func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
6202	l := len(dAtA)
6203	iNdEx := 0
6204	for iNdEx < l {
6205		preIndex := iNdEx
6206		var wire uint64
6207		for shift := uint(0); ; shift += 7 {
6208			if shift >= 64 {
6209				return ErrIntOverflowGenerated
6210			}
6211			if iNdEx >= l {
6212				return io.ErrUnexpectedEOF
6213			}
6214			b := dAtA[iNdEx]
6215			iNdEx++
6216			wire |= (uint64(b) & 0x7F) << shift
6217			if b < 0x80 {
6218				break
6219			}
6220		}
6221		fieldNum := int32(wire >> 3)
6222		wireType := int(wire & 0x7)
6223		if wireType == 4 {
6224			return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
6225		}
6226		if fieldNum <= 0 {
6227			return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
6228		}
6229		switch fieldNum {
6230		case 1:
6231			if wireType != 2 {
6232				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6233			}
6234			var stringLen uint64
6235			for shift := uint(0); ; shift += 7 {
6236				if shift >= 64 {
6237					return ErrIntOverflowGenerated
6238				}
6239				if iNdEx >= l {
6240					return io.ErrUnexpectedEOF
6241				}
6242				b := dAtA[iNdEx]
6243				iNdEx++
6244				stringLen |= (uint64(b) & 0x7F) << shift
6245				if b < 0x80 {
6246					break
6247				}
6248			}
6249			intStringLen := int(stringLen)
6250			if intStringLen < 0 {
6251				return ErrInvalidLengthGenerated
6252			}
6253			postIndex := iNdEx + intStringLen
6254			if postIndex > l {
6255				return io.ErrUnexpectedEOF
6256			}
6257			m.Name = string(dAtA[iNdEx:postIndex])
6258			iNdEx = postIndex
6259		case 2:
6260			if wireType != 2 {
6261				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
6262			}
6263			var msglen int
6264			for shift := uint(0); ; shift += 7 {
6265				if shift >= 64 {
6266					return ErrIntOverflowGenerated
6267				}
6268				if iNdEx >= l {
6269					return io.ErrUnexpectedEOF
6270				}
6271				b := dAtA[iNdEx]
6272				iNdEx++
6273				msglen |= (int(b) & 0x7F) << shift
6274				if b < 0x80 {
6275					break
6276				}
6277			}
6278			if msglen < 0 {
6279				return ErrInvalidLengthGenerated
6280			}
6281			postIndex := iNdEx + msglen
6282			if postIndex > l {
6283				return io.ErrUnexpectedEOF
6284			}
6285			if m.UpdatedAnnotations == nil {
6286				m.UpdatedAnnotations = make(map[string]string)
6287			}
6288			var mapkey string
6289			var mapvalue string
6290			for iNdEx < postIndex {
6291				entryPreIndex := iNdEx
6292				var wire uint64
6293				for shift := uint(0); ; shift += 7 {
6294					if shift >= 64 {
6295						return ErrIntOverflowGenerated
6296					}
6297					if iNdEx >= l {
6298						return io.ErrUnexpectedEOF
6299					}
6300					b := dAtA[iNdEx]
6301					iNdEx++
6302					wire |= (uint64(b) & 0x7F) << shift
6303					if b < 0x80 {
6304						break
6305					}
6306				}
6307				fieldNum := int32(wire >> 3)
6308				if fieldNum == 1 {
6309					var stringLenmapkey uint64
6310					for shift := uint(0); ; shift += 7 {
6311						if shift >= 64 {
6312							return ErrIntOverflowGenerated
6313						}
6314						if iNdEx >= l {
6315							return io.ErrUnexpectedEOF
6316						}
6317						b := dAtA[iNdEx]
6318						iNdEx++
6319						stringLenmapkey |= (uint64(b) & 0x7F) << shift
6320						if b < 0x80 {
6321							break
6322						}
6323					}
6324					intStringLenmapkey := int(stringLenmapkey)
6325					if intStringLenmapkey < 0 {
6326						return ErrInvalidLengthGenerated
6327					}
6328					postStringIndexmapkey := iNdEx + intStringLenmapkey
6329					if postStringIndexmapkey > l {
6330						return io.ErrUnexpectedEOF
6331					}
6332					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6333					iNdEx = postStringIndexmapkey
6334				} else if fieldNum == 2 {
6335					var stringLenmapvalue uint64
6336					for shift := uint(0); ; shift += 7 {
6337						if shift >= 64 {
6338							return ErrIntOverflowGenerated
6339						}
6340						if iNdEx >= l {
6341							return io.ErrUnexpectedEOF
6342						}
6343						b := dAtA[iNdEx]
6344						iNdEx++
6345						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6346						if b < 0x80 {
6347							break
6348						}
6349					}
6350					intStringLenmapvalue := int(stringLenmapvalue)
6351					if intStringLenmapvalue < 0 {
6352						return ErrInvalidLengthGenerated
6353					}
6354					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6355					if postStringIndexmapvalue > l {
6356						return io.ErrUnexpectedEOF
6357					}
6358					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6359					iNdEx = postStringIndexmapvalue
6360				} else {
6361					iNdEx = entryPreIndex
6362					skippy, err := skipGenerated(dAtA[iNdEx:])
6363					if err != nil {
6364						return err
6365					}
6366					if skippy < 0 {
6367						return ErrInvalidLengthGenerated
6368					}
6369					if (iNdEx + skippy) > postIndex {
6370						return io.ErrUnexpectedEOF
6371					}
6372					iNdEx += skippy
6373				}
6374			}
6375			m.UpdatedAnnotations[mapkey] = mapvalue
6376			iNdEx = postIndex
6377		case 3:
6378			if wireType != 2 {
6379				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6380			}
6381			var msglen int
6382			for shift := uint(0); ; shift += 7 {
6383				if shift >= 64 {
6384					return ErrIntOverflowGenerated
6385				}
6386				if iNdEx >= l {
6387					return io.ErrUnexpectedEOF
6388				}
6389				b := dAtA[iNdEx]
6390				iNdEx++
6391				msglen |= (int(b) & 0x7F) << shift
6392				if b < 0x80 {
6393					break
6394				}
6395			}
6396			if msglen < 0 {
6397				return ErrInvalidLengthGenerated
6398			}
6399			postIndex := iNdEx + msglen
6400			if postIndex > l {
6401				return io.ErrUnexpectedEOF
6402			}
6403			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6404				return err
6405			}
6406			iNdEx = postIndex
6407		default:
6408			iNdEx = preIndex
6409			skippy, err := skipGenerated(dAtA[iNdEx:])
6410			if err != nil {
6411				return err
6412			}
6413			if skippy < 0 {
6414				return ErrInvalidLengthGenerated
6415			}
6416			if (iNdEx + skippy) > l {
6417				return io.ErrUnexpectedEOF
6418			}
6419			iNdEx += skippy
6420		}
6421	}
6422
6423	if iNdEx > l {
6424		return io.ErrUnexpectedEOF
6425	}
6426	return nil
6427}
6428func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
6429	l := len(dAtA)
6430	iNdEx := 0
6431	for iNdEx < l {
6432		preIndex := iNdEx
6433		var wire uint64
6434		for shift := uint(0); ; shift += 7 {
6435			if shift >= 64 {
6436				return ErrIntOverflowGenerated
6437			}
6438			if iNdEx >= l {
6439				return io.ErrUnexpectedEOF
6440			}
6441			b := dAtA[iNdEx]
6442			iNdEx++
6443			wire |= (uint64(b) & 0x7F) << shift
6444			if b < 0x80 {
6445				break
6446			}
6447		}
6448		fieldNum := int32(wire >> 3)
6449		wireType := int(wire & 0x7)
6450		if wireType == 4 {
6451			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
6452		}
6453		if fieldNum <= 0 {
6454			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
6455		}
6456		switch fieldNum {
6457		case 1:
6458			if wireType != 0 {
6459				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6460			}
6461			var v int32
6462			for shift := uint(0); ; shift += 7 {
6463				if shift >= 64 {
6464					return ErrIntOverflowGenerated
6465				}
6466				if iNdEx >= l {
6467					return io.ErrUnexpectedEOF
6468				}
6469				b := dAtA[iNdEx]
6470				iNdEx++
6471				v |= (int32(b) & 0x7F) << shift
6472				if b < 0x80 {
6473					break
6474				}
6475			}
6476			m.Replicas = &v
6477		case 2:
6478			if wireType != 2 {
6479				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
6480			}
6481			var msglen int
6482			for shift := uint(0); ; shift += 7 {
6483				if shift >= 64 {
6484					return ErrIntOverflowGenerated
6485				}
6486				if iNdEx >= l {
6487					return io.ErrUnexpectedEOF
6488				}
6489				b := dAtA[iNdEx]
6490				iNdEx++
6491				msglen |= (int(b) & 0x7F) << shift
6492				if b < 0x80 {
6493					break
6494				}
6495			}
6496			if msglen < 0 {
6497				return ErrInvalidLengthGenerated
6498			}
6499			postIndex := iNdEx + msglen
6500			if postIndex > l {
6501				return io.ErrUnexpectedEOF
6502			}
6503			if m.Selector == nil {
6504				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
6505			}
6506			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6507				return err
6508			}
6509			iNdEx = postIndex
6510		case 3:
6511			if wireType != 2 {
6512				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
6513			}
6514			var msglen int
6515			for shift := uint(0); ; shift += 7 {
6516				if shift >= 64 {
6517					return ErrIntOverflowGenerated
6518				}
6519				if iNdEx >= l {
6520					return io.ErrUnexpectedEOF
6521				}
6522				b := dAtA[iNdEx]
6523				iNdEx++
6524				msglen |= (int(b) & 0x7F) << shift
6525				if b < 0x80 {
6526					break
6527				}
6528			}
6529			if msglen < 0 {
6530				return ErrInvalidLengthGenerated
6531			}
6532			postIndex := iNdEx + msglen
6533			if postIndex > l {
6534				return io.ErrUnexpectedEOF
6535			}
6536			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6537				return err
6538			}
6539			iNdEx = postIndex
6540		case 4:
6541			if wireType != 2 {
6542				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
6543			}
6544			var msglen int
6545			for shift := uint(0); ; shift += 7 {
6546				if shift >= 64 {
6547					return ErrIntOverflowGenerated
6548				}
6549				if iNdEx >= l {
6550					return io.ErrUnexpectedEOF
6551				}
6552				b := dAtA[iNdEx]
6553				iNdEx++
6554				msglen |= (int(b) & 0x7F) << shift
6555				if b < 0x80 {
6556					break
6557				}
6558			}
6559			if msglen < 0 {
6560				return ErrInvalidLengthGenerated
6561			}
6562			postIndex := iNdEx + msglen
6563			if postIndex > l {
6564				return io.ErrUnexpectedEOF
6565			}
6566			if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6567				return err
6568			}
6569			iNdEx = postIndex
6570		case 5:
6571			if wireType != 0 {
6572				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
6573			}
6574			m.MinReadySeconds = 0
6575			for shift := uint(0); ; shift += 7 {
6576				if shift >= 64 {
6577					return ErrIntOverflowGenerated
6578				}
6579				if iNdEx >= l {
6580					return io.ErrUnexpectedEOF
6581				}
6582				b := dAtA[iNdEx]
6583				iNdEx++
6584				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
6585				if b < 0x80 {
6586					break
6587				}
6588			}
6589		case 6:
6590			if wireType != 0 {
6591				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
6592			}
6593			var v int32
6594			for shift := uint(0); ; shift += 7 {
6595				if shift >= 64 {
6596					return ErrIntOverflowGenerated
6597				}
6598				if iNdEx >= l {
6599					return io.ErrUnexpectedEOF
6600				}
6601				b := dAtA[iNdEx]
6602				iNdEx++
6603				v |= (int32(b) & 0x7F) << shift
6604				if b < 0x80 {
6605					break
6606				}
6607			}
6608			m.RevisionHistoryLimit = &v
6609		case 7:
6610			if wireType != 0 {
6611				return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
6612			}
6613			var v int
6614			for shift := uint(0); ; shift += 7 {
6615				if shift >= 64 {
6616					return ErrIntOverflowGenerated
6617				}
6618				if iNdEx >= l {
6619					return io.ErrUnexpectedEOF
6620				}
6621				b := dAtA[iNdEx]
6622				iNdEx++
6623				v |= (int(b) & 0x7F) << shift
6624				if b < 0x80 {
6625					break
6626				}
6627			}
6628			m.Paused = bool(v != 0)
6629		case 8:
6630			if wireType != 2 {
6631				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6632			}
6633			var msglen int
6634			for shift := uint(0); ; shift += 7 {
6635				if shift >= 64 {
6636					return ErrIntOverflowGenerated
6637				}
6638				if iNdEx >= l {
6639					return io.ErrUnexpectedEOF
6640				}
6641				b := dAtA[iNdEx]
6642				iNdEx++
6643				msglen |= (int(b) & 0x7F) << shift
6644				if b < 0x80 {
6645					break
6646				}
6647			}
6648			if msglen < 0 {
6649				return ErrInvalidLengthGenerated
6650			}
6651			postIndex := iNdEx + msglen
6652			if postIndex > l {
6653				return io.ErrUnexpectedEOF
6654			}
6655			if m.RollbackTo == nil {
6656				m.RollbackTo = &RollbackConfig{}
6657			}
6658			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6659				return err
6660			}
6661			iNdEx = postIndex
6662		case 9:
6663			if wireType != 0 {
6664				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
6665			}
6666			var v int32
6667			for shift := uint(0); ; shift += 7 {
6668				if shift >= 64 {
6669					return ErrIntOverflowGenerated
6670				}
6671				if iNdEx >= l {
6672					return io.ErrUnexpectedEOF
6673				}
6674				b := dAtA[iNdEx]
6675				iNdEx++
6676				v |= (int32(b) & 0x7F) << shift
6677				if b < 0x80 {
6678					break
6679				}
6680			}
6681			m.ProgressDeadlineSeconds = &v
6682		default:
6683			iNdEx = preIndex
6684			skippy, err := skipGenerated(dAtA[iNdEx:])
6685			if err != nil {
6686				return err
6687			}
6688			if skippy < 0 {
6689				return ErrInvalidLengthGenerated
6690			}
6691			if (iNdEx + skippy) > l {
6692				return io.ErrUnexpectedEOF
6693			}
6694			iNdEx += skippy
6695		}
6696	}
6697
6698	if iNdEx > l {
6699		return io.ErrUnexpectedEOF
6700	}
6701	return nil
6702}
6703func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
6704	l := len(dAtA)
6705	iNdEx := 0
6706	for iNdEx < l {
6707		preIndex := iNdEx
6708		var wire uint64
6709		for shift := uint(0); ; shift += 7 {
6710			if shift >= 64 {
6711				return ErrIntOverflowGenerated
6712			}
6713			if iNdEx >= l {
6714				return io.ErrUnexpectedEOF
6715			}
6716			b := dAtA[iNdEx]
6717			iNdEx++
6718			wire |= (uint64(b) & 0x7F) << shift
6719			if b < 0x80 {
6720				break
6721			}
6722		}
6723		fieldNum := int32(wire >> 3)
6724		wireType := int(wire & 0x7)
6725		if wireType == 4 {
6726			return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
6727		}
6728		if fieldNum <= 0 {
6729			return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6730		}
6731		switch fieldNum {
6732		case 1:
6733			if wireType != 0 {
6734				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6735			}
6736			m.ObservedGeneration = 0
6737			for shift := uint(0); ; shift += 7 {
6738				if shift >= 64 {
6739					return ErrIntOverflowGenerated
6740				}
6741				if iNdEx >= l {
6742					return io.ErrUnexpectedEOF
6743				}
6744				b := dAtA[iNdEx]
6745				iNdEx++
6746				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
6747				if b < 0x80 {
6748					break
6749				}
6750			}
6751		case 2:
6752			if wireType != 0 {
6753				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6754			}
6755			m.Replicas = 0
6756			for shift := uint(0); ; shift += 7 {
6757				if shift >= 64 {
6758					return ErrIntOverflowGenerated
6759				}
6760				if iNdEx >= l {
6761					return io.ErrUnexpectedEOF
6762				}
6763				b := dAtA[iNdEx]
6764				iNdEx++
6765				m.Replicas |= (int32(b) & 0x7F) << shift
6766				if b < 0x80 {
6767					break
6768				}
6769			}
6770		case 3:
6771			if wireType != 0 {
6772				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
6773			}
6774			m.UpdatedReplicas = 0
6775			for shift := uint(0); ; shift += 7 {
6776				if shift >= 64 {
6777					return ErrIntOverflowGenerated
6778				}
6779				if iNdEx >= l {
6780					return io.ErrUnexpectedEOF
6781				}
6782				b := dAtA[iNdEx]
6783				iNdEx++
6784				m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
6785				if b < 0x80 {
6786					break
6787				}
6788			}
6789		case 4:
6790			if wireType != 0 {
6791				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
6792			}
6793			m.AvailableReplicas = 0
6794			for shift := uint(0); ; shift += 7 {
6795				if shift >= 64 {
6796					return ErrIntOverflowGenerated
6797				}
6798				if iNdEx >= l {
6799					return io.ErrUnexpectedEOF
6800				}
6801				b := dAtA[iNdEx]
6802				iNdEx++
6803				m.AvailableReplicas |= (int32(b) & 0x7F) << shift
6804				if b < 0x80 {
6805					break
6806				}
6807			}
6808		case 5:
6809			if wireType != 0 {
6810				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
6811			}
6812			m.UnavailableReplicas = 0
6813			for shift := uint(0); ; shift += 7 {
6814				if shift >= 64 {
6815					return ErrIntOverflowGenerated
6816				}
6817				if iNdEx >= l {
6818					return io.ErrUnexpectedEOF
6819				}
6820				b := dAtA[iNdEx]
6821				iNdEx++
6822				m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
6823				if b < 0x80 {
6824					break
6825				}
6826			}
6827		case 6:
6828			if wireType != 2 {
6829				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
6830			}
6831			var msglen int
6832			for shift := uint(0); ; shift += 7 {
6833				if shift >= 64 {
6834					return ErrIntOverflowGenerated
6835				}
6836				if iNdEx >= l {
6837					return io.ErrUnexpectedEOF
6838				}
6839				b := dAtA[iNdEx]
6840				iNdEx++
6841				msglen |= (int(b) & 0x7F) << shift
6842				if b < 0x80 {
6843					break
6844				}
6845			}
6846			if msglen < 0 {
6847				return ErrInvalidLengthGenerated
6848			}
6849			postIndex := iNdEx + msglen
6850			if postIndex > l {
6851				return io.ErrUnexpectedEOF
6852			}
6853			m.Conditions = append(m.Conditions, DeploymentCondition{})
6854			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6855				return err
6856			}
6857			iNdEx = postIndex
6858		case 7:
6859			if wireType != 0 {
6860				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6861			}
6862			m.ReadyReplicas = 0
6863			for shift := uint(0); ; shift += 7 {
6864				if shift >= 64 {
6865					return ErrIntOverflowGenerated
6866				}
6867				if iNdEx >= l {
6868					return io.ErrUnexpectedEOF
6869				}
6870				b := dAtA[iNdEx]
6871				iNdEx++
6872				m.ReadyReplicas |= (int32(b) & 0x7F) << shift
6873				if b < 0x80 {
6874					break
6875				}
6876			}
6877		case 8:
6878			if wireType != 0 {
6879				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
6880			}
6881			var v int32
6882			for shift := uint(0); ; shift += 7 {
6883				if shift >= 64 {
6884					return ErrIntOverflowGenerated
6885				}
6886				if iNdEx >= l {
6887					return io.ErrUnexpectedEOF
6888				}
6889				b := dAtA[iNdEx]
6890				iNdEx++
6891				v |= (int32(b) & 0x7F) << shift
6892				if b < 0x80 {
6893					break
6894				}
6895			}
6896			m.CollisionCount = &v
6897		default:
6898			iNdEx = preIndex
6899			skippy, err := skipGenerated(dAtA[iNdEx:])
6900			if err != nil {
6901				return err
6902			}
6903			if skippy < 0 {
6904				return ErrInvalidLengthGenerated
6905			}
6906			if (iNdEx + skippy) > l {
6907				return io.ErrUnexpectedEOF
6908			}
6909			iNdEx += skippy
6910		}
6911	}
6912
6913	if iNdEx > l {
6914		return io.ErrUnexpectedEOF
6915	}
6916	return nil
6917}
6918func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
6919	l := len(dAtA)
6920	iNdEx := 0
6921	for iNdEx < l {
6922		preIndex := iNdEx
6923		var wire uint64
6924		for shift := uint(0); ; shift += 7 {
6925			if shift >= 64 {
6926				return ErrIntOverflowGenerated
6927			}
6928			if iNdEx >= l {
6929				return io.ErrUnexpectedEOF
6930			}
6931			b := dAtA[iNdEx]
6932			iNdEx++
6933			wire |= (uint64(b) & 0x7F) << shift
6934			if b < 0x80 {
6935				break
6936			}
6937		}
6938		fieldNum := int32(wire >> 3)
6939		wireType := int(wire & 0x7)
6940		if wireType == 4 {
6941			return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
6942		}
6943		if fieldNum <= 0 {
6944			return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
6945		}
6946		switch fieldNum {
6947		case 1:
6948			if wireType != 2 {
6949				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6950			}
6951			var stringLen uint64
6952			for shift := uint(0); ; shift += 7 {
6953				if shift >= 64 {
6954					return ErrIntOverflowGenerated
6955				}
6956				if iNdEx >= l {
6957					return io.ErrUnexpectedEOF
6958				}
6959				b := dAtA[iNdEx]
6960				iNdEx++
6961				stringLen |= (uint64(b) & 0x7F) << shift
6962				if b < 0x80 {
6963					break
6964				}
6965			}
6966			intStringLen := int(stringLen)
6967			if intStringLen < 0 {
6968				return ErrInvalidLengthGenerated
6969			}
6970			postIndex := iNdEx + intStringLen
6971			if postIndex > l {
6972				return io.ErrUnexpectedEOF
6973			}
6974			m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
6975			iNdEx = postIndex
6976		case 2:
6977			if wireType != 2 {
6978				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6979			}
6980			var msglen int
6981			for shift := uint(0); ; shift += 7 {
6982				if shift >= 64 {
6983					return ErrIntOverflowGenerated
6984				}
6985				if iNdEx >= l {
6986					return io.ErrUnexpectedEOF
6987				}
6988				b := dAtA[iNdEx]
6989				iNdEx++
6990				msglen |= (int(b) & 0x7F) << shift
6991				if b < 0x80 {
6992					break
6993				}
6994			}
6995			if msglen < 0 {
6996				return ErrInvalidLengthGenerated
6997			}
6998			postIndex := iNdEx + msglen
6999			if postIndex > l {
7000				return io.ErrUnexpectedEOF
7001			}
7002			if m.RollingUpdate == nil {
7003				m.RollingUpdate = &RollingUpdateDeployment{}
7004			}
7005			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7006				return err
7007			}
7008			iNdEx = postIndex
7009		default:
7010			iNdEx = preIndex
7011			skippy, err := skipGenerated(dAtA[iNdEx:])
7012			if err != nil {
7013				return err
7014			}
7015			if skippy < 0 {
7016				return ErrInvalidLengthGenerated
7017			}
7018			if (iNdEx + skippy) > l {
7019				return io.ErrUnexpectedEOF
7020			}
7021			iNdEx += skippy
7022		}
7023	}
7024
7025	if iNdEx > l {
7026		return io.ErrUnexpectedEOF
7027	}
7028	return nil
7029}
7030func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error {
7031	l := len(dAtA)
7032	iNdEx := 0
7033	for iNdEx < l {
7034		preIndex := iNdEx
7035		var wire uint64
7036		for shift := uint(0); ; shift += 7 {
7037			if shift >= 64 {
7038				return ErrIntOverflowGenerated
7039			}
7040			if iNdEx >= l {
7041				return io.ErrUnexpectedEOF
7042			}
7043			b := dAtA[iNdEx]
7044			iNdEx++
7045			wire |= (uint64(b) & 0x7F) << shift
7046			if b < 0x80 {
7047				break
7048			}
7049		}
7050		fieldNum := int32(wire >> 3)
7051		wireType := int(wire & 0x7)
7052		if wireType == 4 {
7053			return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
7054		}
7055		if fieldNum <= 0 {
7056			return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
7057		}
7058		switch fieldNum {
7059		case 1:
7060			if wireType != 2 {
7061				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
7062			}
7063			var stringLen uint64
7064			for shift := uint(0); ; shift += 7 {
7065				if shift >= 64 {
7066					return ErrIntOverflowGenerated
7067				}
7068				if iNdEx >= l {
7069					return io.ErrUnexpectedEOF
7070				}
7071				b := dAtA[iNdEx]
7072				iNdEx++
7073				stringLen |= (uint64(b) & 0x7F) << shift
7074				if b < 0x80 {
7075					break
7076				}
7077			}
7078			intStringLen := int(stringLen)
7079			if intStringLen < 0 {
7080				return ErrInvalidLengthGenerated
7081			}
7082			postIndex := iNdEx + intStringLen
7083			if postIndex > l {
7084				return io.ErrUnexpectedEOF
7085			}
7086			m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex])
7087			iNdEx = postIndex
7088		case 2:
7089			if wireType != 2 {
7090				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
7091			}
7092			var msglen int
7093			for shift := uint(0); ; shift += 7 {
7094				if shift >= 64 {
7095					return ErrIntOverflowGenerated
7096				}
7097				if iNdEx >= l {
7098					return io.ErrUnexpectedEOF
7099				}
7100				b := dAtA[iNdEx]
7101				iNdEx++
7102				msglen |= (int(b) & 0x7F) << shift
7103				if b < 0x80 {
7104					break
7105				}
7106			}
7107			if msglen < 0 {
7108				return ErrInvalidLengthGenerated
7109			}
7110			postIndex := iNdEx + msglen
7111			if postIndex > l {
7112				return io.ErrUnexpectedEOF
7113			}
7114			m.Ranges = append(m.Ranges, IDRange{})
7115			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7116				return err
7117			}
7118			iNdEx = postIndex
7119		default:
7120			iNdEx = preIndex
7121			skippy, err := skipGenerated(dAtA[iNdEx:])
7122			if err != nil {
7123				return err
7124			}
7125			if skippy < 0 {
7126				return ErrInvalidLengthGenerated
7127			}
7128			if (iNdEx + skippy) > l {
7129				return io.ErrUnexpectedEOF
7130			}
7131			iNdEx += skippy
7132		}
7133	}
7134
7135	if iNdEx > l {
7136		return io.ErrUnexpectedEOF
7137	}
7138	return nil
7139}
7140func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error {
7141	l := len(dAtA)
7142	iNdEx := 0
7143	for iNdEx < l {
7144		preIndex := iNdEx
7145		var wire uint64
7146		for shift := uint(0); ; shift += 7 {
7147			if shift >= 64 {
7148				return ErrIntOverflowGenerated
7149			}
7150			if iNdEx >= l {
7151				return io.ErrUnexpectedEOF
7152			}
7153			b := dAtA[iNdEx]
7154			iNdEx++
7155			wire |= (uint64(b) & 0x7F) << shift
7156			if b < 0x80 {
7157				break
7158			}
7159		}
7160		fieldNum := int32(wire >> 3)
7161		wireType := int(wire & 0x7)
7162		if wireType == 4 {
7163			return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
7164		}
7165		if fieldNum <= 0 {
7166			return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
7167		}
7168		switch fieldNum {
7169		case 1:
7170			if wireType != 2 {
7171				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
7172			}
7173			var stringLen uint64
7174			for shift := uint(0); ; shift += 7 {
7175				if shift >= 64 {
7176					return ErrIntOverflowGenerated
7177				}
7178				if iNdEx >= l {
7179					return io.ErrUnexpectedEOF
7180				}
7181				b := dAtA[iNdEx]
7182				iNdEx++
7183				stringLen |= (uint64(b) & 0x7F) << shift
7184				if b < 0x80 {
7185					break
7186				}
7187			}
7188			intStringLen := int(stringLen)
7189			if intStringLen < 0 {
7190				return ErrInvalidLengthGenerated
7191			}
7192			postIndex := iNdEx + intStringLen
7193			if postIndex > l {
7194				return io.ErrUnexpectedEOF
7195			}
7196			m.Path = string(dAtA[iNdEx:postIndex])
7197			iNdEx = postIndex
7198		case 2:
7199			if wireType != 2 {
7200				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
7201			}
7202			var msglen int
7203			for shift := uint(0); ; shift += 7 {
7204				if shift >= 64 {
7205					return ErrIntOverflowGenerated
7206				}
7207				if iNdEx >= l {
7208					return io.ErrUnexpectedEOF
7209				}
7210				b := dAtA[iNdEx]
7211				iNdEx++
7212				msglen |= (int(b) & 0x7F) << shift
7213				if b < 0x80 {
7214					break
7215				}
7216			}
7217			if msglen < 0 {
7218				return ErrInvalidLengthGenerated
7219			}
7220			postIndex := iNdEx + msglen
7221			if postIndex > l {
7222				return io.ErrUnexpectedEOF
7223			}
7224			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7225				return err
7226			}
7227			iNdEx = postIndex
7228		default:
7229			iNdEx = preIndex
7230			skippy, err := skipGenerated(dAtA[iNdEx:])
7231			if err != nil {
7232				return err
7233			}
7234			if skippy < 0 {
7235				return ErrInvalidLengthGenerated
7236			}
7237			if (iNdEx + skippy) > l {
7238				return io.ErrUnexpectedEOF
7239			}
7240			iNdEx += skippy
7241		}
7242	}
7243
7244	if iNdEx > l {
7245		return io.ErrUnexpectedEOF
7246	}
7247	return nil
7248}
7249func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error {
7250	l := len(dAtA)
7251	iNdEx := 0
7252	for iNdEx < l {
7253		preIndex := iNdEx
7254		var wire uint64
7255		for shift := uint(0); ; shift += 7 {
7256			if shift >= 64 {
7257				return ErrIntOverflowGenerated
7258			}
7259			if iNdEx >= l {
7260				return io.ErrUnexpectedEOF
7261			}
7262			b := dAtA[iNdEx]
7263			iNdEx++
7264			wire |= (uint64(b) & 0x7F) << shift
7265			if b < 0x80 {
7266				break
7267			}
7268		}
7269		fieldNum := int32(wire >> 3)
7270		wireType := int(wire & 0x7)
7271		if wireType == 4 {
7272			return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
7273		}
7274		if fieldNum <= 0 {
7275			return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
7276		}
7277		switch fieldNum {
7278		case 1:
7279			if wireType != 2 {
7280				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
7281			}
7282			var msglen int
7283			for shift := uint(0); ; shift += 7 {
7284				if shift >= 64 {
7285					return ErrIntOverflowGenerated
7286				}
7287				if iNdEx >= l {
7288					return io.ErrUnexpectedEOF
7289				}
7290				b := dAtA[iNdEx]
7291				iNdEx++
7292				msglen |= (int(b) & 0x7F) << shift
7293				if b < 0x80 {
7294					break
7295				}
7296			}
7297			if msglen < 0 {
7298				return ErrInvalidLengthGenerated
7299			}
7300			postIndex := iNdEx + msglen
7301			if postIndex > l {
7302				return io.ErrUnexpectedEOF
7303			}
7304			m.Paths = append(m.Paths, HTTPIngressPath{})
7305			if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7306				return err
7307			}
7308			iNdEx = postIndex
7309		default:
7310			iNdEx = preIndex
7311			skippy, err := skipGenerated(dAtA[iNdEx:])
7312			if err != nil {
7313				return err
7314			}
7315			if skippy < 0 {
7316				return ErrInvalidLengthGenerated
7317			}
7318			if (iNdEx + skippy) > l {
7319				return io.ErrUnexpectedEOF
7320			}
7321			iNdEx += skippy
7322		}
7323	}
7324
7325	if iNdEx > l {
7326		return io.ErrUnexpectedEOF
7327	}
7328	return nil
7329}
7330func (m *HostPortRange) Unmarshal(dAtA []byte) error {
7331	l := len(dAtA)
7332	iNdEx := 0
7333	for iNdEx < l {
7334		preIndex := iNdEx
7335		var wire uint64
7336		for shift := uint(0); ; shift += 7 {
7337			if shift >= 64 {
7338				return ErrIntOverflowGenerated
7339			}
7340			if iNdEx >= l {
7341				return io.ErrUnexpectedEOF
7342			}
7343			b := dAtA[iNdEx]
7344			iNdEx++
7345			wire |= (uint64(b) & 0x7F) << shift
7346			if b < 0x80 {
7347				break
7348			}
7349		}
7350		fieldNum := int32(wire >> 3)
7351		wireType := int(wire & 0x7)
7352		if wireType == 4 {
7353			return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group")
7354		}
7355		if fieldNum <= 0 {
7356			return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire)
7357		}
7358		switch fieldNum {
7359		case 1:
7360			if wireType != 0 {
7361				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7362			}
7363			m.Min = 0
7364			for shift := uint(0); ; shift += 7 {
7365				if shift >= 64 {
7366					return ErrIntOverflowGenerated
7367				}
7368				if iNdEx >= l {
7369					return io.ErrUnexpectedEOF
7370				}
7371				b := dAtA[iNdEx]
7372				iNdEx++
7373				m.Min |= (int32(b) & 0x7F) << shift
7374				if b < 0x80 {
7375					break
7376				}
7377			}
7378		case 2:
7379			if wireType != 0 {
7380				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7381			}
7382			m.Max = 0
7383			for shift := uint(0); ; shift += 7 {
7384				if shift >= 64 {
7385					return ErrIntOverflowGenerated
7386				}
7387				if iNdEx >= l {
7388					return io.ErrUnexpectedEOF
7389				}
7390				b := dAtA[iNdEx]
7391				iNdEx++
7392				m.Max |= (int32(b) & 0x7F) << shift
7393				if b < 0x80 {
7394					break
7395				}
7396			}
7397		default:
7398			iNdEx = preIndex
7399			skippy, err := skipGenerated(dAtA[iNdEx:])
7400			if err != nil {
7401				return err
7402			}
7403			if skippy < 0 {
7404				return ErrInvalidLengthGenerated
7405			}
7406			if (iNdEx + skippy) > l {
7407				return io.ErrUnexpectedEOF
7408			}
7409			iNdEx += skippy
7410		}
7411	}
7412
7413	if iNdEx > l {
7414		return io.ErrUnexpectedEOF
7415	}
7416	return nil
7417}
7418func (m *IDRange) Unmarshal(dAtA []byte) error {
7419	l := len(dAtA)
7420	iNdEx := 0
7421	for iNdEx < l {
7422		preIndex := iNdEx
7423		var wire uint64
7424		for shift := uint(0); ; shift += 7 {
7425			if shift >= 64 {
7426				return ErrIntOverflowGenerated
7427			}
7428			if iNdEx >= l {
7429				return io.ErrUnexpectedEOF
7430			}
7431			b := dAtA[iNdEx]
7432			iNdEx++
7433			wire |= (uint64(b) & 0x7F) << shift
7434			if b < 0x80 {
7435				break
7436			}
7437		}
7438		fieldNum := int32(wire >> 3)
7439		wireType := int(wire & 0x7)
7440		if wireType == 4 {
7441			return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
7442		}
7443		if fieldNum <= 0 {
7444			return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
7445		}
7446		switch fieldNum {
7447		case 1:
7448			if wireType != 0 {
7449				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7450			}
7451			m.Min = 0
7452			for shift := uint(0); ; shift += 7 {
7453				if shift >= 64 {
7454					return ErrIntOverflowGenerated
7455				}
7456				if iNdEx >= l {
7457					return io.ErrUnexpectedEOF
7458				}
7459				b := dAtA[iNdEx]
7460				iNdEx++
7461				m.Min |= (int64(b) & 0x7F) << shift
7462				if b < 0x80 {
7463					break
7464				}
7465			}
7466		case 2:
7467			if wireType != 0 {
7468				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7469			}
7470			m.Max = 0
7471			for shift := uint(0); ; shift += 7 {
7472				if shift >= 64 {
7473					return ErrIntOverflowGenerated
7474				}
7475				if iNdEx >= l {
7476					return io.ErrUnexpectedEOF
7477				}
7478				b := dAtA[iNdEx]
7479				iNdEx++
7480				m.Max |= (int64(b) & 0x7F) << shift
7481				if b < 0x80 {
7482					break
7483				}
7484			}
7485		default:
7486			iNdEx = preIndex
7487			skippy, err := skipGenerated(dAtA[iNdEx:])
7488			if err != nil {
7489				return err
7490			}
7491			if skippy < 0 {
7492				return ErrInvalidLengthGenerated
7493			}
7494			if (iNdEx + skippy) > l {
7495				return io.ErrUnexpectedEOF
7496			}
7497			iNdEx += skippy
7498		}
7499	}
7500
7501	if iNdEx > l {
7502		return io.ErrUnexpectedEOF
7503	}
7504	return nil
7505}
7506func (m *IPBlock) Unmarshal(dAtA []byte) error {
7507	l := len(dAtA)
7508	iNdEx := 0
7509	for iNdEx < l {
7510		preIndex := iNdEx
7511		var wire uint64
7512		for shift := uint(0); ; shift += 7 {
7513			if shift >= 64 {
7514				return ErrIntOverflowGenerated
7515			}
7516			if iNdEx >= l {
7517				return io.ErrUnexpectedEOF
7518			}
7519			b := dAtA[iNdEx]
7520			iNdEx++
7521			wire |= (uint64(b) & 0x7F) << shift
7522			if b < 0x80 {
7523				break
7524			}
7525		}
7526		fieldNum := int32(wire >> 3)
7527		wireType := int(wire & 0x7)
7528		if wireType == 4 {
7529			return fmt.Errorf("proto: IPBlock: wiretype end group for non-group")
7530		}
7531		if fieldNum <= 0 {
7532			return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire)
7533		}
7534		switch fieldNum {
7535		case 1:
7536			if wireType != 2 {
7537				return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType)
7538			}
7539			var stringLen uint64
7540			for shift := uint(0); ; shift += 7 {
7541				if shift >= 64 {
7542					return ErrIntOverflowGenerated
7543				}
7544				if iNdEx >= l {
7545					return io.ErrUnexpectedEOF
7546				}
7547				b := dAtA[iNdEx]
7548				iNdEx++
7549				stringLen |= (uint64(b) & 0x7F) << shift
7550				if b < 0x80 {
7551					break
7552				}
7553			}
7554			intStringLen := int(stringLen)
7555			if intStringLen < 0 {
7556				return ErrInvalidLengthGenerated
7557			}
7558			postIndex := iNdEx + intStringLen
7559			if postIndex > l {
7560				return io.ErrUnexpectedEOF
7561			}
7562			m.CIDR = string(dAtA[iNdEx:postIndex])
7563			iNdEx = postIndex
7564		case 2:
7565			if wireType != 2 {
7566				return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType)
7567			}
7568			var stringLen uint64
7569			for shift := uint(0); ; shift += 7 {
7570				if shift >= 64 {
7571					return ErrIntOverflowGenerated
7572				}
7573				if iNdEx >= l {
7574					return io.ErrUnexpectedEOF
7575				}
7576				b := dAtA[iNdEx]
7577				iNdEx++
7578				stringLen |= (uint64(b) & 0x7F) << shift
7579				if b < 0x80 {
7580					break
7581				}
7582			}
7583			intStringLen := int(stringLen)
7584			if intStringLen < 0 {
7585				return ErrInvalidLengthGenerated
7586			}
7587			postIndex := iNdEx + intStringLen
7588			if postIndex > l {
7589				return io.ErrUnexpectedEOF
7590			}
7591			m.Except = append(m.Except, string(dAtA[iNdEx:postIndex]))
7592			iNdEx = postIndex
7593		default:
7594			iNdEx = preIndex
7595			skippy, err := skipGenerated(dAtA[iNdEx:])
7596			if err != nil {
7597				return err
7598			}
7599			if skippy < 0 {
7600				return ErrInvalidLengthGenerated
7601			}
7602			if (iNdEx + skippy) > l {
7603				return io.ErrUnexpectedEOF
7604			}
7605			iNdEx += skippy
7606		}
7607	}
7608
7609	if iNdEx > l {
7610		return io.ErrUnexpectedEOF
7611	}
7612	return nil
7613}
7614func (m *Ingress) Unmarshal(dAtA []byte) error {
7615	l := len(dAtA)
7616	iNdEx := 0
7617	for iNdEx < l {
7618		preIndex := iNdEx
7619		var wire uint64
7620		for shift := uint(0); ; shift += 7 {
7621			if shift >= 64 {
7622				return ErrIntOverflowGenerated
7623			}
7624			if iNdEx >= l {
7625				return io.ErrUnexpectedEOF
7626			}
7627			b := dAtA[iNdEx]
7628			iNdEx++
7629			wire |= (uint64(b) & 0x7F) << shift
7630			if b < 0x80 {
7631				break
7632			}
7633		}
7634		fieldNum := int32(wire >> 3)
7635		wireType := int(wire & 0x7)
7636		if wireType == 4 {
7637			return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
7638		}
7639		if fieldNum <= 0 {
7640			return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
7641		}
7642		switch fieldNum {
7643		case 1:
7644			if wireType != 2 {
7645				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
7646			}
7647			var msglen int
7648			for shift := uint(0); ; shift += 7 {
7649				if shift >= 64 {
7650					return ErrIntOverflowGenerated
7651				}
7652				if iNdEx >= l {
7653					return io.ErrUnexpectedEOF
7654				}
7655				b := dAtA[iNdEx]
7656				iNdEx++
7657				msglen |= (int(b) & 0x7F) << shift
7658				if b < 0x80 {
7659					break
7660				}
7661			}
7662			if msglen < 0 {
7663				return ErrInvalidLengthGenerated
7664			}
7665			postIndex := iNdEx + msglen
7666			if postIndex > l {
7667				return io.ErrUnexpectedEOF
7668			}
7669			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7670				return err
7671			}
7672			iNdEx = postIndex
7673		case 2:
7674			if wireType != 2 {
7675				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
7676			}
7677			var msglen int
7678			for shift := uint(0); ; shift += 7 {
7679				if shift >= 64 {
7680					return ErrIntOverflowGenerated
7681				}
7682				if iNdEx >= l {
7683					return io.ErrUnexpectedEOF
7684				}
7685				b := dAtA[iNdEx]
7686				iNdEx++
7687				msglen |= (int(b) & 0x7F) << shift
7688				if b < 0x80 {
7689					break
7690				}
7691			}
7692			if msglen < 0 {
7693				return ErrInvalidLengthGenerated
7694			}
7695			postIndex := iNdEx + msglen
7696			if postIndex > l {
7697				return io.ErrUnexpectedEOF
7698			}
7699			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7700				return err
7701			}
7702			iNdEx = postIndex
7703		case 3:
7704			if wireType != 2 {
7705				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7706			}
7707			var msglen int
7708			for shift := uint(0); ; shift += 7 {
7709				if shift >= 64 {
7710					return ErrIntOverflowGenerated
7711				}
7712				if iNdEx >= l {
7713					return io.ErrUnexpectedEOF
7714				}
7715				b := dAtA[iNdEx]
7716				iNdEx++
7717				msglen |= (int(b) & 0x7F) << shift
7718				if b < 0x80 {
7719					break
7720				}
7721			}
7722			if msglen < 0 {
7723				return ErrInvalidLengthGenerated
7724			}
7725			postIndex := iNdEx + msglen
7726			if postIndex > l {
7727				return io.ErrUnexpectedEOF
7728			}
7729			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7730				return err
7731			}
7732			iNdEx = postIndex
7733		default:
7734			iNdEx = preIndex
7735			skippy, err := skipGenerated(dAtA[iNdEx:])
7736			if err != nil {
7737				return err
7738			}
7739			if skippy < 0 {
7740				return ErrInvalidLengthGenerated
7741			}
7742			if (iNdEx + skippy) > l {
7743				return io.ErrUnexpectedEOF
7744			}
7745			iNdEx += skippy
7746		}
7747	}
7748
7749	if iNdEx > l {
7750		return io.ErrUnexpectedEOF
7751	}
7752	return nil
7753}
7754func (m *IngressBackend) Unmarshal(dAtA []byte) error {
7755	l := len(dAtA)
7756	iNdEx := 0
7757	for iNdEx < l {
7758		preIndex := iNdEx
7759		var wire uint64
7760		for shift := uint(0); ; shift += 7 {
7761			if shift >= 64 {
7762				return ErrIntOverflowGenerated
7763			}
7764			if iNdEx >= l {
7765				return io.ErrUnexpectedEOF
7766			}
7767			b := dAtA[iNdEx]
7768			iNdEx++
7769			wire |= (uint64(b) & 0x7F) << shift
7770			if b < 0x80 {
7771				break
7772			}
7773		}
7774		fieldNum := int32(wire >> 3)
7775		wireType := int(wire & 0x7)
7776		if wireType == 4 {
7777			return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
7778		}
7779		if fieldNum <= 0 {
7780			return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
7781		}
7782		switch fieldNum {
7783		case 1:
7784			if wireType != 2 {
7785				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
7786			}
7787			var stringLen uint64
7788			for shift := uint(0); ; shift += 7 {
7789				if shift >= 64 {
7790					return ErrIntOverflowGenerated
7791				}
7792				if iNdEx >= l {
7793					return io.ErrUnexpectedEOF
7794				}
7795				b := dAtA[iNdEx]
7796				iNdEx++
7797				stringLen |= (uint64(b) & 0x7F) << shift
7798				if b < 0x80 {
7799					break
7800				}
7801			}
7802			intStringLen := int(stringLen)
7803			if intStringLen < 0 {
7804				return ErrInvalidLengthGenerated
7805			}
7806			postIndex := iNdEx + intStringLen
7807			if postIndex > l {
7808				return io.ErrUnexpectedEOF
7809			}
7810			m.ServiceName = string(dAtA[iNdEx:postIndex])
7811			iNdEx = postIndex
7812		case 2:
7813			if wireType != 2 {
7814				return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
7815			}
7816			var msglen int
7817			for shift := uint(0); ; shift += 7 {
7818				if shift >= 64 {
7819					return ErrIntOverflowGenerated
7820				}
7821				if iNdEx >= l {
7822					return io.ErrUnexpectedEOF
7823				}
7824				b := dAtA[iNdEx]
7825				iNdEx++
7826				msglen |= (int(b) & 0x7F) << shift
7827				if b < 0x80 {
7828					break
7829				}
7830			}
7831			if msglen < 0 {
7832				return ErrInvalidLengthGenerated
7833			}
7834			postIndex := iNdEx + msglen
7835			if postIndex > l {
7836				return io.ErrUnexpectedEOF
7837			}
7838			if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7839				return err
7840			}
7841			iNdEx = postIndex
7842		default:
7843			iNdEx = preIndex
7844			skippy, err := skipGenerated(dAtA[iNdEx:])
7845			if err != nil {
7846				return err
7847			}
7848			if skippy < 0 {
7849				return ErrInvalidLengthGenerated
7850			}
7851			if (iNdEx + skippy) > l {
7852				return io.ErrUnexpectedEOF
7853			}
7854			iNdEx += skippy
7855		}
7856	}
7857
7858	if iNdEx > l {
7859		return io.ErrUnexpectedEOF
7860	}
7861	return nil
7862}
7863func (m *IngressList) Unmarshal(dAtA []byte) error {
7864	l := len(dAtA)
7865	iNdEx := 0
7866	for iNdEx < l {
7867		preIndex := iNdEx
7868		var wire uint64
7869		for shift := uint(0); ; shift += 7 {
7870			if shift >= 64 {
7871				return ErrIntOverflowGenerated
7872			}
7873			if iNdEx >= l {
7874				return io.ErrUnexpectedEOF
7875			}
7876			b := dAtA[iNdEx]
7877			iNdEx++
7878			wire |= (uint64(b) & 0x7F) << shift
7879			if b < 0x80 {
7880				break
7881			}
7882		}
7883		fieldNum := int32(wire >> 3)
7884		wireType := int(wire & 0x7)
7885		if wireType == 4 {
7886			return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
7887		}
7888		if fieldNum <= 0 {
7889			return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
7890		}
7891		switch fieldNum {
7892		case 1:
7893			if wireType != 2 {
7894				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7895			}
7896			var msglen int
7897			for shift := uint(0); ; shift += 7 {
7898				if shift >= 64 {
7899					return ErrIntOverflowGenerated
7900				}
7901				if iNdEx >= l {
7902					return io.ErrUnexpectedEOF
7903				}
7904				b := dAtA[iNdEx]
7905				iNdEx++
7906				msglen |= (int(b) & 0x7F) << shift
7907				if b < 0x80 {
7908					break
7909				}
7910			}
7911			if msglen < 0 {
7912				return ErrInvalidLengthGenerated
7913			}
7914			postIndex := iNdEx + msglen
7915			if postIndex > l {
7916				return io.ErrUnexpectedEOF
7917			}
7918			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7919				return err
7920			}
7921			iNdEx = postIndex
7922		case 2:
7923			if wireType != 2 {
7924				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7925			}
7926			var msglen int
7927			for shift := uint(0); ; shift += 7 {
7928				if shift >= 64 {
7929					return ErrIntOverflowGenerated
7930				}
7931				if iNdEx >= l {
7932					return io.ErrUnexpectedEOF
7933				}
7934				b := dAtA[iNdEx]
7935				iNdEx++
7936				msglen |= (int(b) & 0x7F) << shift
7937				if b < 0x80 {
7938					break
7939				}
7940			}
7941			if msglen < 0 {
7942				return ErrInvalidLengthGenerated
7943			}
7944			postIndex := iNdEx + msglen
7945			if postIndex > l {
7946				return io.ErrUnexpectedEOF
7947			}
7948			m.Items = append(m.Items, Ingress{})
7949			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7950				return err
7951			}
7952			iNdEx = postIndex
7953		default:
7954			iNdEx = preIndex
7955			skippy, err := skipGenerated(dAtA[iNdEx:])
7956			if err != nil {
7957				return err
7958			}
7959			if skippy < 0 {
7960				return ErrInvalidLengthGenerated
7961			}
7962			if (iNdEx + skippy) > l {
7963				return io.ErrUnexpectedEOF
7964			}
7965			iNdEx += skippy
7966		}
7967	}
7968
7969	if iNdEx > l {
7970		return io.ErrUnexpectedEOF
7971	}
7972	return nil
7973}
7974func (m *IngressRule) Unmarshal(dAtA []byte) error {
7975	l := len(dAtA)
7976	iNdEx := 0
7977	for iNdEx < l {
7978		preIndex := iNdEx
7979		var wire uint64
7980		for shift := uint(0); ; shift += 7 {
7981			if shift >= 64 {
7982				return ErrIntOverflowGenerated
7983			}
7984			if iNdEx >= l {
7985				return io.ErrUnexpectedEOF
7986			}
7987			b := dAtA[iNdEx]
7988			iNdEx++
7989			wire |= (uint64(b) & 0x7F) << shift
7990			if b < 0x80 {
7991				break
7992			}
7993		}
7994		fieldNum := int32(wire >> 3)
7995		wireType := int(wire & 0x7)
7996		if wireType == 4 {
7997			return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
7998		}
7999		if fieldNum <= 0 {
8000			return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8001		}
8002		switch fieldNum {
8003		case 1:
8004			if wireType != 2 {
8005				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
8006			}
8007			var stringLen uint64
8008			for shift := uint(0); ; shift += 7 {
8009				if shift >= 64 {
8010					return ErrIntOverflowGenerated
8011				}
8012				if iNdEx >= l {
8013					return io.ErrUnexpectedEOF
8014				}
8015				b := dAtA[iNdEx]
8016				iNdEx++
8017				stringLen |= (uint64(b) & 0x7F) << shift
8018				if b < 0x80 {
8019					break
8020				}
8021			}
8022			intStringLen := int(stringLen)
8023			if intStringLen < 0 {
8024				return ErrInvalidLengthGenerated
8025			}
8026			postIndex := iNdEx + intStringLen
8027			if postIndex > l {
8028				return io.ErrUnexpectedEOF
8029			}
8030			m.Host = string(dAtA[iNdEx:postIndex])
8031			iNdEx = postIndex
8032		case 2:
8033			if wireType != 2 {
8034				return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
8035			}
8036			var msglen int
8037			for shift := uint(0); ; shift += 7 {
8038				if shift >= 64 {
8039					return ErrIntOverflowGenerated
8040				}
8041				if iNdEx >= l {
8042					return io.ErrUnexpectedEOF
8043				}
8044				b := dAtA[iNdEx]
8045				iNdEx++
8046				msglen |= (int(b) & 0x7F) << shift
8047				if b < 0x80 {
8048					break
8049				}
8050			}
8051			if msglen < 0 {
8052				return ErrInvalidLengthGenerated
8053			}
8054			postIndex := iNdEx + msglen
8055			if postIndex > l {
8056				return io.ErrUnexpectedEOF
8057			}
8058			if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8059				return err
8060			}
8061			iNdEx = postIndex
8062		default:
8063			iNdEx = preIndex
8064			skippy, err := skipGenerated(dAtA[iNdEx:])
8065			if err != nil {
8066				return err
8067			}
8068			if skippy < 0 {
8069				return ErrInvalidLengthGenerated
8070			}
8071			if (iNdEx + skippy) > l {
8072				return io.ErrUnexpectedEOF
8073			}
8074			iNdEx += skippy
8075		}
8076	}
8077
8078	if iNdEx > l {
8079		return io.ErrUnexpectedEOF
8080	}
8081	return nil
8082}
8083func (m *IngressRuleValue) Unmarshal(dAtA []byte) error {
8084	l := len(dAtA)
8085	iNdEx := 0
8086	for iNdEx < l {
8087		preIndex := iNdEx
8088		var wire uint64
8089		for shift := uint(0); ; shift += 7 {
8090			if shift >= 64 {
8091				return ErrIntOverflowGenerated
8092			}
8093			if iNdEx >= l {
8094				return io.ErrUnexpectedEOF
8095			}
8096			b := dAtA[iNdEx]
8097			iNdEx++
8098			wire |= (uint64(b) & 0x7F) << shift
8099			if b < 0x80 {
8100				break
8101			}
8102		}
8103		fieldNum := int32(wire >> 3)
8104		wireType := int(wire & 0x7)
8105		if wireType == 4 {
8106			return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
8107		}
8108		if fieldNum <= 0 {
8109			return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
8110		}
8111		switch fieldNum {
8112		case 1:
8113			if wireType != 2 {
8114				return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
8115			}
8116			var msglen int
8117			for shift := uint(0); ; shift += 7 {
8118				if shift >= 64 {
8119					return ErrIntOverflowGenerated
8120				}
8121				if iNdEx >= l {
8122					return io.ErrUnexpectedEOF
8123				}
8124				b := dAtA[iNdEx]
8125				iNdEx++
8126				msglen |= (int(b) & 0x7F) << shift
8127				if b < 0x80 {
8128					break
8129				}
8130			}
8131			if msglen < 0 {
8132				return ErrInvalidLengthGenerated
8133			}
8134			postIndex := iNdEx + msglen
8135			if postIndex > l {
8136				return io.ErrUnexpectedEOF
8137			}
8138			if m.HTTP == nil {
8139				m.HTTP = &HTTPIngressRuleValue{}
8140			}
8141			if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8142				return err
8143			}
8144			iNdEx = postIndex
8145		default:
8146			iNdEx = preIndex
8147			skippy, err := skipGenerated(dAtA[iNdEx:])
8148			if err != nil {
8149				return err
8150			}
8151			if skippy < 0 {
8152				return ErrInvalidLengthGenerated
8153			}
8154			if (iNdEx + skippy) > l {
8155				return io.ErrUnexpectedEOF
8156			}
8157			iNdEx += skippy
8158		}
8159	}
8160
8161	if iNdEx > l {
8162		return io.ErrUnexpectedEOF
8163	}
8164	return nil
8165}
8166func (m *IngressSpec) Unmarshal(dAtA []byte) error {
8167	l := len(dAtA)
8168	iNdEx := 0
8169	for iNdEx < l {
8170		preIndex := iNdEx
8171		var wire uint64
8172		for shift := uint(0); ; shift += 7 {
8173			if shift >= 64 {
8174				return ErrIntOverflowGenerated
8175			}
8176			if iNdEx >= l {
8177				return io.ErrUnexpectedEOF
8178			}
8179			b := dAtA[iNdEx]
8180			iNdEx++
8181			wire |= (uint64(b) & 0x7F) << shift
8182			if b < 0x80 {
8183				break
8184			}
8185		}
8186		fieldNum := int32(wire >> 3)
8187		wireType := int(wire & 0x7)
8188		if wireType == 4 {
8189			return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
8190		}
8191		if fieldNum <= 0 {
8192			return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
8193		}
8194		switch fieldNum {
8195		case 1:
8196			if wireType != 2 {
8197				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
8198			}
8199			var msglen int
8200			for shift := uint(0); ; shift += 7 {
8201				if shift >= 64 {
8202					return ErrIntOverflowGenerated
8203				}
8204				if iNdEx >= l {
8205					return io.ErrUnexpectedEOF
8206				}
8207				b := dAtA[iNdEx]
8208				iNdEx++
8209				msglen |= (int(b) & 0x7F) << shift
8210				if b < 0x80 {
8211					break
8212				}
8213			}
8214			if msglen < 0 {
8215				return ErrInvalidLengthGenerated
8216			}
8217			postIndex := iNdEx + msglen
8218			if postIndex > l {
8219				return io.ErrUnexpectedEOF
8220			}
8221			if m.Backend == nil {
8222				m.Backend = &IngressBackend{}
8223			}
8224			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8225				return err
8226			}
8227			iNdEx = postIndex
8228		case 2:
8229			if wireType != 2 {
8230				return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
8231			}
8232			var msglen int
8233			for shift := uint(0); ; shift += 7 {
8234				if shift >= 64 {
8235					return ErrIntOverflowGenerated
8236				}
8237				if iNdEx >= l {
8238					return io.ErrUnexpectedEOF
8239				}
8240				b := dAtA[iNdEx]
8241				iNdEx++
8242				msglen |= (int(b) & 0x7F) << shift
8243				if b < 0x80 {
8244					break
8245				}
8246			}
8247			if msglen < 0 {
8248				return ErrInvalidLengthGenerated
8249			}
8250			postIndex := iNdEx + msglen
8251			if postIndex > l {
8252				return io.ErrUnexpectedEOF
8253			}
8254			m.TLS = append(m.TLS, IngressTLS{})
8255			if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8256				return err
8257			}
8258			iNdEx = postIndex
8259		case 3:
8260			if wireType != 2 {
8261				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
8262			}
8263			var msglen int
8264			for shift := uint(0); ; shift += 7 {
8265				if shift >= 64 {
8266					return ErrIntOverflowGenerated
8267				}
8268				if iNdEx >= l {
8269					return io.ErrUnexpectedEOF
8270				}
8271				b := dAtA[iNdEx]
8272				iNdEx++
8273				msglen |= (int(b) & 0x7F) << shift
8274				if b < 0x80 {
8275					break
8276				}
8277			}
8278			if msglen < 0 {
8279				return ErrInvalidLengthGenerated
8280			}
8281			postIndex := iNdEx + msglen
8282			if postIndex > l {
8283				return io.ErrUnexpectedEOF
8284			}
8285			m.Rules = append(m.Rules, IngressRule{})
8286			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8287				return err
8288			}
8289			iNdEx = postIndex
8290		default:
8291			iNdEx = preIndex
8292			skippy, err := skipGenerated(dAtA[iNdEx:])
8293			if err != nil {
8294				return err
8295			}
8296			if skippy < 0 {
8297				return ErrInvalidLengthGenerated
8298			}
8299			if (iNdEx + skippy) > l {
8300				return io.ErrUnexpectedEOF
8301			}
8302			iNdEx += skippy
8303		}
8304	}
8305
8306	if iNdEx > l {
8307		return io.ErrUnexpectedEOF
8308	}
8309	return nil
8310}
8311func (m *IngressStatus) Unmarshal(dAtA []byte) error {
8312	l := len(dAtA)
8313	iNdEx := 0
8314	for iNdEx < l {
8315		preIndex := iNdEx
8316		var wire uint64
8317		for shift := uint(0); ; shift += 7 {
8318			if shift >= 64 {
8319				return ErrIntOverflowGenerated
8320			}
8321			if iNdEx >= l {
8322				return io.ErrUnexpectedEOF
8323			}
8324			b := dAtA[iNdEx]
8325			iNdEx++
8326			wire |= (uint64(b) & 0x7F) << shift
8327			if b < 0x80 {
8328				break
8329			}
8330		}
8331		fieldNum := int32(wire >> 3)
8332		wireType := int(wire & 0x7)
8333		if wireType == 4 {
8334			return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
8335		}
8336		if fieldNum <= 0 {
8337			return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
8338		}
8339		switch fieldNum {
8340		case 1:
8341			if wireType != 2 {
8342				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
8343			}
8344			var msglen int
8345			for shift := uint(0); ; shift += 7 {
8346				if shift >= 64 {
8347					return ErrIntOverflowGenerated
8348				}
8349				if iNdEx >= l {
8350					return io.ErrUnexpectedEOF
8351				}
8352				b := dAtA[iNdEx]
8353				iNdEx++
8354				msglen |= (int(b) & 0x7F) << shift
8355				if b < 0x80 {
8356					break
8357				}
8358			}
8359			if msglen < 0 {
8360				return ErrInvalidLengthGenerated
8361			}
8362			postIndex := iNdEx + msglen
8363			if postIndex > l {
8364				return io.ErrUnexpectedEOF
8365			}
8366			if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8367				return err
8368			}
8369			iNdEx = postIndex
8370		default:
8371			iNdEx = preIndex
8372			skippy, err := skipGenerated(dAtA[iNdEx:])
8373			if err != nil {
8374				return err
8375			}
8376			if skippy < 0 {
8377				return ErrInvalidLengthGenerated
8378			}
8379			if (iNdEx + skippy) > l {
8380				return io.ErrUnexpectedEOF
8381			}
8382			iNdEx += skippy
8383		}
8384	}
8385
8386	if iNdEx > l {
8387		return io.ErrUnexpectedEOF
8388	}
8389	return nil
8390}
8391func (m *IngressTLS) Unmarshal(dAtA []byte) error {
8392	l := len(dAtA)
8393	iNdEx := 0
8394	for iNdEx < l {
8395		preIndex := iNdEx
8396		var wire uint64
8397		for shift := uint(0); ; shift += 7 {
8398			if shift >= 64 {
8399				return ErrIntOverflowGenerated
8400			}
8401			if iNdEx >= l {
8402				return io.ErrUnexpectedEOF
8403			}
8404			b := dAtA[iNdEx]
8405			iNdEx++
8406			wire |= (uint64(b) & 0x7F) << shift
8407			if b < 0x80 {
8408				break
8409			}
8410		}
8411		fieldNum := int32(wire >> 3)
8412		wireType := int(wire & 0x7)
8413		if wireType == 4 {
8414			return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
8415		}
8416		if fieldNum <= 0 {
8417			return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
8418		}
8419		switch fieldNum {
8420		case 1:
8421			if wireType != 2 {
8422				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
8423			}
8424			var stringLen uint64
8425			for shift := uint(0); ; shift += 7 {
8426				if shift >= 64 {
8427					return ErrIntOverflowGenerated
8428				}
8429				if iNdEx >= l {
8430					return io.ErrUnexpectedEOF
8431				}
8432				b := dAtA[iNdEx]
8433				iNdEx++
8434				stringLen |= (uint64(b) & 0x7F) << shift
8435				if b < 0x80 {
8436					break
8437				}
8438			}
8439			intStringLen := int(stringLen)
8440			if intStringLen < 0 {
8441				return ErrInvalidLengthGenerated
8442			}
8443			postIndex := iNdEx + intStringLen
8444			if postIndex > l {
8445				return io.ErrUnexpectedEOF
8446			}
8447			m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
8448			iNdEx = postIndex
8449		case 2:
8450			if wireType != 2 {
8451				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
8452			}
8453			var stringLen uint64
8454			for shift := uint(0); ; shift += 7 {
8455				if shift >= 64 {
8456					return ErrIntOverflowGenerated
8457				}
8458				if iNdEx >= l {
8459					return io.ErrUnexpectedEOF
8460				}
8461				b := dAtA[iNdEx]
8462				iNdEx++
8463				stringLen |= (uint64(b) & 0x7F) << shift
8464				if b < 0x80 {
8465					break
8466				}
8467			}
8468			intStringLen := int(stringLen)
8469			if intStringLen < 0 {
8470				return ErrInvalidLengthGenerated
8471			}
8472			postIndex := iNdEx + intStringLen
8473			if postIndex > l {
8474				return io.ErrUnexpectedEOF
8475			}
8476			m.SecretName = string(dAtA[iNdEx:postIndex])
8477			iNdEx = postIndex
8478		default:
8479			iNdEx = preIndex
8480			skippy, err := skipGenerated(dAtA[iNdEx:])
8481			if err != nil {
8482				return err
8483			}
8484			if skippy < 0 {
8485				return ErrInvalidLengthGenerated
8486			}
8487			if (iNdEx + skippy) > l {
8488				return io.ErrUnexpectedEOF
8489			}
8490			iNdEx += skippy
8491		}
8492	}
8493
8494	if iNdEx > l {
8495		return io.ErrUnexpectedEOF
8496	}
8497	return nil
8498}
8499func (m *NetworkPolicy) Unmarshal(dAtA []byte) error {
8500	l := len(dAtA)
8501	iNdEx := 0
8502	for iNdEx < l {
8503		preIndex := iNdEx
8504		var wire uint64
8505		for shift := uint(0); ; shift += 7 {
8506			if shift >= 64 {
8507				return ErrIntOverflowGenerated
8508			}
8509			if iNdEx >= l {
8510				return io.ErrUnexpectedEOF
8511			}
8512			b := dAtA[iNdEx]
8513			iNdEx++
8514			wire |= (uint64(b) & 0x7F) << shift
8515			if b < 0x80 {
8516				break
8517			}
8518		}
8519		fieldNum := int32(wire >> 3)
8520		wireType := int(wire & 0x7)
8521		if wireType == 4 {
8522			return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group")
8523		}
8524		if fieldNum <= 0 {
8525			return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
8526		}
8527		switch fieldNum {
8528		case 1:
8529			if wireType != 2 {
8530				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
8531			}
8532			var msglen int
8533			for shift := uint(0); ; shift += 7 {
8534				if shift >= 64 {
8535					return ErrIntOverflowGenerated
8536				}
8537				if iNdEx >= l {
8538					return io.ErrUnexpectedEOF
8539				}
8540				b := dAtA[iNdEx]
8541				iNdEx++
8542				msglen |= (int(b) & 0x7F) << shift
8543				if b < 0x80 {
8544					break
8545				}
8546			}
8547			if msglen < 0 {
8548				return ErrInvalidLengthGenerated
8549			}
8550			postIndex := iNdEx + msglen
8551			if postIndex > l {
8552				return io.ErrUnexpectedEOF
8553			}
8554			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8555				return err
8556			}
8557			iNdEx = postIndex
8558		case 2:
8559			if wireType != 2 {
8560				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
8561			}
8562			var msglen int
8563			for shift := uint(0); ; shift += 7 {
8564				if shift >= 64 {
8565					return ErrIntOverflowGenerated
8566				}
8567				if iNdEx >= l {
8568					return io.ErrUnexpectedEOF
8569				}
8570				b := dAtA[iNdEx]
8571				iNdEx++
8572				msglen |= (int(b) & 0x7F) << shift
8573				if b < 0x80 {
8574					break
8575				}
8576			}
8577			if msglen < 0 {
8578				return ErrInvalidLengthGenerated
8579			}
8580			postIndex := iNdEx + msglen
8581			if postIndex > l {
8582				return io.ErrUnexpectedEOF
8583			}
8584			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8585				return err
8586			}
8587			iNdEx = postIndex
8588		default:
8589			iNdEx = preIndex
8590			skippy, err := skipGenerated(dAtA[iNdEx:])
8591			if err != nil {
8592				return err
8593			}
8594			if skippy < 0 {
8595				return ErrInvalidLengthGenerated
8596			}
8597			if (iNdEx + skippy) > l {
8598				return io.ErrUnexpectedEOF
8599			}
8600			iNdEx += skippy
8601		}
8602	}
8603
8604	if iNdEx > l {
8605		return io.ErrUnexpectedEOF
8606	}
8607	return nil
8608}
8609func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error {
8610	l := len(dAtA)
8611	iNdEx := 0
8612	for iNdEx < l {
8613		preIndex := iNdEx
8614		var wire uint64
8615		for shift := uint(0); ; shift += 7 {
8616			if shift >= 64 {
8617				return ErrIntOverflowGenerated
8618			}
8619			if iNdEx >= l {
8620				return io.ErrUnexpectedEOF
8621			}
8622			b := dAtA[iNdEx]
8623			iNdEx++
8624			wire |= (uint64(b) & 0x7F) << shift
8625			if b < 0x80 {
8626				break
8627			}
8628		}
8629		fieldNum := int32(wire >> 3)
8630		wireType := int(wire & 0x7)
8631		if wireType == 4 {
8632			return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group")
8633		}
8634		if fieldNum <= 0 {
8635			return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8636		}
8637		switch fieldNum {
8638		case 1:
8639			if wireType != 2 {
8640				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8641			}
8642			var msglen int
8643			for shift := uint(0); ; shift += 7 {
8644				if shift >= 64 {
8645					return ErrIntOverflowGenerated
8646				}
8647				if iNdEx >= l {
8648					return io.ErrUnexpectedEOF
8649				}
8650				b := dAtA[iNdEx]
8651				iNdEx++
8652				msglen |= (int(b) & 0x7F) << shift
8653				if b < 0x80 {
8654					break
8655				}
8656			}
8657			if msglen < 0 {
8658				return ErrInvalidLengthGenerated
8659			}
8660			postIndex := iNdEx + msglen
8661			if postIndex > l {
8662				return io.ErrUnexpectedEOF
8663			}
8664			m.Ports = append(m.Ports, NetworkPolicyPort{})
8665			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8666				return err
8667			}
8668			iNdEx = postIndex
8669		case 2:
8670			if wireType != 2 {
8671				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
8672			}
8673			var msglen int
8674			for shift := uint(0); ; shift += 7 {
8675				if shift >= 64 {
8676					return ErrIntOverflowGenerated
8677				}
8678				if iNdEx >= l {
8679					return io.ErrUnexpectedEOF
8680				}
8681				b := dAtA[iNdEx]
8682				iNdEx++
8683				msglen |= (int(b) & 0x7F) << shift
8684				if b < 0x80 {
8685					break
8686				}
8687			}
8688			if msglen < 0 {
8689				return ErrInvalidLengthGenerated
8690			}
8691			postIndex := iNdEx + msglen
8692			if postIndex > l {
8693				return io.ErrUnexpectedEOF
8694			}
8695			m.To = append(m.To, NetworkPolicyPeer{})
8696			if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8697				return err
8698			}
8699			iNdEx = postIndex
8700		default:
8701			iNdEx = preIndex
8702			skippy, err := skipGenerated(dAtA[iNdEx:])
8703			if err != nil {
8704				return err
8705			}
8706			if skippy < 0 {
8707				return ErrInvalidLengthGenerated
8708			}
8709			if (iNdEx + skippy) > l {
8710				return io.ErrUnexpectedEOF
8711			}
8712			iNdEx += skippy
8713		}
8714	}
8715
8716	if iNdEx > l {
8717		return io.ErrUnexpectedEOF
8718	}
8719	return nil
8720}
8721func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error {
8722	l := len(dAtA)
8723	iNdEx := 0
8724	for iNdEx < l {
8725		preIndex := iNdEx
8726		var wire uint64
8727		for shift := uint(0); ; shift += 7 {
8728			if shift >= 64 {
8729				return ErrIntOverflowGenerated
8730			}
8731			if iNdEx >= l {
8732				return io.ErrUnexpectedEOF
8733			}
8734			b := dAtA[iNdEx]
8735			iNdEx++
8736			wire |= (uint64(b) & 0x7F) << shift
8737			if b < 0x80 {
8738				break
8739			}
8740		}
8741		fieldNum := int32(wire >> 3)
8742		wireType := int(wire & 0x7)
8743		if wireType == 4 {
8744			return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group")
8745		}
8746		if fieldNum <= 0 {
8747			return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8748		}
8749		switch fieldNum {
8750		case 1:
8751			if wireType != 2 {
8752				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8753			}
8754			var msglen int
8755			for shift := uint(0); ; shift += 7 {
8756				if shift >= 64 {
8757					return ErrIntOverflowGenerated
8758				}
8759				if iNdEx >= l {
8760					return io.ErrUnexpectedEOF
8761				}
8762				b := dAtA[iNdEx]
8763				iNdEx++
8764				msglen |= (int(b) & 0x7F) << shift
8765				if b < 0x80 {
8766					break
8767				}
8768			}
8769			if msglen < 0 {
8770				return ErrInvalidLengthGenerated
8771			}
8772			postIndex := iNdEx + msglen
8773			if postIndex > l {
8774				return io.ErrUnexpectedEOF
8775			}
8776			m.Ports = append(m.Ports, NetworkPolicyPort{})
8777			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8778				return err
8779			}
8780			iNdEx = postIndex
8781		case 2:
8782			if wireType != 2 {
8783				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
8784			}
8785			var msglen int
8786			for shift := uint(0); ; shift += 7 {
8787				if shift >= 64 {
8788					return ErrIntOverflowGenerated
8789				}
8790				if iNdEx >= l {
8791					return io.ErrUnexpectedEOF
8792				}
8793				b := dAtA[iNdEx]
8794				iNdEx++
8795				msglen |= (int(b) & 0x7F) << shift
8796				if b < 0x80 {
8797					break
8798				}
8799			}
8800			if msglen < 0 {
8801				return ErrInvalidLengthGenerated
8802			}
8803			postIndex := iNdEx + msglen
8804			if postIndex > l {
8805				return io.ErrUnexpectedEOF
8806			}
8807			m.From = append(m.From, NetworkPolicyPeer{})
8808			if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8809				return err
8810			}
8811			iNdEx = postIndex
8812		default:
8813			iNdEx = preIndex
8814			skippy, err := skipGenerated(dAtA[iNdEx:])
8815			if err != nil {
8816				return err
8817			}
8818			if skippy < 0 {
8819				return ErrInvalidLengthGenerated
8820			}
8821			if (iNdEx + skippy) > l {
8822				return io.ErrUnexpectedEOF
8823			}
8824			iNdEx += skippy
8825		}
8826	}
8827
8828	if iNdEx > l {
8829		return io.ErrUnexpectedEOF
8830	}
8831	return nil
8832}
8833func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error {
8834	l := len(dAtA)
8835	iNdEx := 0
8836	for iNdEx < l {
8837		preIndex := iNdEx
8838		var wire uint64
8839		for shift := uint(0); ; shift += 7 {
8840			if shift >= 64 {
8841				return ErrIntOverflowGenerated
8842			}
8843			if iNdEx >= l {
8844				return io.ErrUnexpectedEOF
8845			}
8846			b := dAtA[iNdEx]
8847			iNdEx++
8848			wire |= (uint64(b) & 0x7F) << shift
8849			if b < 0x80 {
8850				break
8851			}
8852		}
8853		fieldNum := int32(wire >> 3)
8854		wireType := int(wire & 0x7)
8855		if wireType == 4 {
8856			return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group")
8857		}
8858		if fieldNum <= 0 {
8859			return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
8860		}
8861		switch fieldNum {
8862		case 1:
8863			if wireType != 2 {
8864				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
8865			}
8866			var msglen int
8867			for shift := uint(0); ; shift += 7 {
8868				if shift >= 64 {
8869					return ErrIntOverflowGenerated
8870				}
8871				if iNdEx >= l {
8872					return io.ErrUnexpectedEOF
8873				}
8874				b := dAtA[iNdEx]
8875				iNdEx++
8876				msglen |= (int(b) & 0x7F) << shift
8877				if b < 0x80 {
8878					break
8879				}
8880			}
8881			if msglen < 0 {
8882				return ErrInvalidLengthGenerated
8883			}
8884			postIndex := iNdEx + msglen
8885			if postIndex > l {
8886				return io.ErrUnexpectedEOF
8887			}
8888			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8889				return err
8890			}
8891			iNdEx = postIndex
8892		case 2:
8893			if wireType != 2 {
8894				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
8895			}
8896			var msglen int
8897			for shift := uint(0); ; shift += 7 {
8898				if shift >= 64 {
8899					return ErrIntOverflowGenerated
8900				}
8901				if iNdEx >= l {
8902					return io.ErrUnexpectedEOF
8903				}
8904				b := dAtA[iNdEx]
8905				iNdEx++
8906				msglen |= (int(b) & 0x7F) << shift
8907				if b < 0x80 {
8908					break
8909				}
8910			}
8911			if msglen < 0 {
8912				return ErrInvalidLengthGenerated
8913			}
8914			postIndex := iNdEx + msglen
8915			if postIndex > l {
8916				return io.ErrUnexpectedEOF
8917			}
8918			m.Items = append(m.Items, NetworkPolicy{})
8919			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8920				return err
8921			}
8922			iNdEx = postIndex
8923		default:
8924			iNdEx = preIndex
8925			skippy, err := skipGenerated(dAtA[iNdEx:])
8926			if err != nil {
8927				return err
8928			}
8929			if skippy < 0 {
8930				return ErrInvalidLengthGenerated
8931			}
8932			if (iNdEx + skippy) > l {
8933				return io.ErrUnexpectedEOF
8934			}
8935			iNdEx += skippy
8936		}
8937	}
8938
8939	if iNdEx > l {
8940		return io.ErrUnexpectedEOF
8941	}
8942	return nil
8943}
8944func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error {
8945	l := len(dAtA)
8946	iNdEx := 0
8947	for iNdEx < l {
8948		preIndex := iNdEx
8949		var wire uint64
8950		for shift := uint(0); ; shift += 7 {
8951			if shift >= 64 {
8952				return ErrIntOverflowGenerated
8953			}
8954			if iNdEx >= l {
8955				return io.ErrUnexpectedEOF
8956			}
8957			b := dAtA[iNdEx]
8958			iNdEx++
8959			wire |= (uint64(b) & 0x7F) << shift
8960			if b < 0x80 {
8961				break
8962			}
8963		}
8964		fieldNum := int32(wire >> 3)
8965		wireType := int(wire & 0x7)
8966		if wireType == 4 {
8967			return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group")
8968		}
8969		if fieldNum <= 0 {
8970			return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire)
8971		}
8972		switch fieldNum {
8973		case 1:
8974			if wireType != 2 {
8975				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
8976			}
8977			var msglen int
8978			for shift := uint(0); ; shift += 7 {
8979				if shift >= 64 {
8980					return ErrIntOverflowGenerated
8981				}
8982				if iNdEx >= l {
8983					return io.ErrUnexpectedEOF
8984				}
8985				b := dAtA[iNdEx]
8986				iNdEx++
8987				msglen |= (int(b) & 0x7F) << shift
8988				if b < 0x80 {
8989					break
8990				}
8991			}
8992			if msglen < 0 {
8993				return ErrInvalidLengthGenerated
8994			}
8995			postIndex := iNdEx + msglen
8996			if postIndex > l {
8997				return io.ErrUnexpectedEOF
8998			}
8999			if m.PodSelector == nil {
9000				m.PodSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
9001			}
9002			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9003				return err
9004			}
9005			iNdEx = postIndex
9006		case 2:
9007			if wireType != 2 {
9008				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
9009			}
9010			var msglen int
9011			for shift := uint(0); ; shift += 7 {
9012				if shift >= 64 {
9013					return ErrIntOverflowGenerated
9014				}
9015				if iNdEx >= l {
9016					return io.ErrUnexpectedEOF
9017				}
9018				b := dAtA[iNdEx]
9019				iNdEx++
9020				msglen |= (int(b) & 0x7F) << shift
9021				if b < 0x80 {
9022					break
9023				}
9024			}
9025			if msglen < 0 {
9026				return ErrInvalidLengthGenerated
9027			}
9028			postIndex := iNdEx + msglen
9029			if postIndex > l {
9030				return io.ErrUnexpectedEOF
9031			}
9032			if m.NamespaceSelector == nil {
9033				m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
9034			}
9035			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9036				return err
9037			}
9038			iNdEx = postIndex
9039		case 3:
9040			if wireType != 2 {
9041				return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType)
9042			}
9043			var msglen int
9044			for shift := uint(0); ; shift += 7 {
9045				if shift >= 64 {
9046					return ErrIntOverflowGenerated
9047				}
9048				if iNdEx >= l {
9049					return io.ErrUnexpectedEOF
9050				}
9051				b := dAtA[iNdEx]
9052				iNdEx++
9053				msglen |= (int(b) & 0x7F) << shift
9054				if b < 0x80 {
9055					break
9056				}
9057			}
9058			if msglen < 0 {
9059				return ErrInvalidLengthGenerated
9060			}
9061			postIndex := iNdEx + msglen
9062			if postIndex > l {
9063				return io.ErrUnexpectedEOF
9064			}
9065			if m.IPBlock == nil {
9066				m.IPBlock = &IPBlock{}
9067			}
9068			if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9069				return err
9070			}
9071			iNdEx = postIndex
9072		default:
9073			iNdEx = preIndex
9074			skippy, err := skipGenerated(dAtA[iNdEx:])
9075			if err != nil {
9076				return err
9077			}
9078			if skippy < 0 {
9079				return ErrInvalidLengthGenerated
9080			}
9081			if (iNdEx + skippy) > l {
9082				return io.ErrUnexpectedEOF
9083			}
9084			iNdEx += skippy
9085		}
9086	}
9087
9088	if iNdEx > l {
9089		return io.ErrUnexpectedEOF
9090	}
9091	return nil
9092}
9093func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error {
9094	l := len(dAtA)
9095	iNdEx := 0
9096	for iNdEx < l {
9097		preIndex := iNdEx
9098		var wire uint64
9099		for shift := uint(0); ; shift += 7 {
9100			if shift >= 64 {
9101				return ErrIntOverflowGenerated
9102			}
9103			if iNdEx >= l {
9104				return io.ErrUnexpectedEOF
9105			}
9106			b := dAtA[iNdEx]
9107			iNdEx++
9108			wire |= (uint64(b) & 0x7F) << shift
9109			if b < 0x80 {
9110				break
9111			}
9112		}
9113		fieldNum := int32(wire >> 3)
9114		wireType := int(wire & 0x7)
9115		if wireType == 4 {
9116			return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group")
9117		}
9118		if fieldNum <= 0 {
9119			return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire)
9120		}
9121		switch fieldNum {
9122		case 1:
9123			if wireType != 2 {
9124				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
9125			}
9126			var stringLen uint64
9127			for shift := uint(0); ; shift += 7 {
9128				if shift >= 64 {
9129					return ErrIntOverflowGenerated
9130				}
9131				if iNdEx >= l {
9132					return io.ErrUnexpectedEOF
9133				}
9134				b := dAtA[iNdEx]
9135				iNdEx++
9136				stringLen |= (uint64(b) & 0x7F) << shift
9137				if b < 0x80 {
9138					break
9139				}
9140			}
9141			intStringLen := int(stringLen)
9142			if intStringLen < 0 {
9143				return ErrInvalidLengthGenerated
9144			}
9145			postIndex := iNdEx + intStringLen
9146			if postIndex > l {
9147				return io.ErrUnexpectedEOF
9148			}
9149			s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
9150			m.Protocol = &s
9151			iNdEx = postIndex
9152		case 2:
9153			if wireType != 2 {
9154				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
9155			}
9156			var msglen int
9157			for shift := uint(0); ; shift += 7 {
9158				if shift >= 64 {
9159					return ErrIntOverflowGenerated
9160				}
9161				if iNdEx >= l {
9162					return io.ErrUnexpectedEOF
9163				}
9164				b := dAtA[iNdEx]
9165				iNdEx++
9166				msglen |= (int(b) & 0x7F) << shift
9167				if b < 0x80 {
9168					break
9169				}
9170			}
9171			if msglen < 0 {
9172				return ErrInvalidLengthGenerated
9173			}
9174			postIndex := iNdEx + msglen
9175			if postIndex > l {
9176				return io.ErrUnexpectedEOF
9177			}
9178			if m.Port == nil {
9179				m.Port = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
9180			}
9181			if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9182				return err
9183			}
9184			iNdEx = postIndex
9185		default:
9186			iNdEx = preIndex
9187			skippy, err := skipGenerated(dAtA[iNdEx:])
9188			if err != nil {
9189				return err
9190			}
9191			if skippy < 0 {
9192				return ErrInvalidLengthGenerated
9193			}
9194			if (iNdEx + skippy) > l {
9195				return io.ErrUnexpectedEOF
9196			}
9197			iNdEx += skippy
9198		}
9199	}
9200
9201	if iNdEx > l {
9202		return io.ErrUnexpectedEOF
9203	}
9204	return nil
9205}
9206func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error {
9207	l := len(dAtA)
9208	iNdEx := 0
9209	for iNdEx < l {
9210		preIndex := iNdEx
9211		var wire uint64
9212		for shift := uint(0); ; shift += 7 {
9213			if shift >= 64 {
9214				return ErrIntOverflowGenerated
9215			}
9216			if iNdEx >= l {
9217				return io.ErrUnexpectedEOF
9218			}
9219			b := dAtA[iNdEx]
9220			iNdEx++
9221			wire |= (uint64(b) & 0x7F) << shift
9222			if b < 0x80 {
9223				break
9224			}
9225		}
9226		fieldNum := int32(wire >> 3)
9227		wireType := int(wire & 0x7)
9228		if wireType == 4 {
9229			return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group")
9230		}
9231		if fieldNum <= 0 {
9232			return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
9233		}
9234		switch fieldNum {
9235		case 1:
9236			if wireType != 2 {
9237				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
9238			}
9239			var msglen int
9240			for shift := uint(0); ; shift += 7 {
9241				if shift >= 64 {
9242					return ErrIntOverflowGenerated
9243				}
9244				if iNdEx >= l {
9245					return io.ErrUnexpectedEOF
9246				}
9247				b := dAtA[iNdEx]
9248				iNdEx++
9249				msglen |= (int(b) & 0x7F) << shift
9250				if b < 0x80 {
9251					break
9252				}
9253			}
9254			if msglen < 0 {
9255				return ErrInvalidLengthGenerated
9256			}
9257			postIndex := iNdEx + msglen
9258			if postIndex > l {
9259				return io.ErrUnexpectedEOF
9260			}
9261			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9262				return err
9263			}
9264			iNdEx = postIndex
9265		case 2:
9266			if wireType != 2 {
9267				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
9268			}
9269			var msglen int
9270			for shift := uint(0); ; shift += 7 {
9271				if shift >= 64 {
9272					return ErrIntOverflowGenerated
9273				}
9274				if iNdEx >= l {
9275					return io.ErrUnexpectedEOF
9276				}
9277				b := dAtA[iNdEx]
9278				iNdEx++
9279				msglen |= (int(b) & 0x7F) << shift
9280				if b < 0x80 {
9281					break
9282				}
9283			}
9284			if msglen < 0 {
9285				return ErrInvalidLengthGenerated
9286			}
9287			postIndex := iNdEx + msglen
9288			if postIndex > l {
9289				return io.ErrUnexpectedEOF
9290			}
9291			m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{})
9292			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9293				return err
9294			}
9295			iNdEx = postIndex
9296		case 3:
9297			if wireType != 2 {
9298				return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType)
9299			}
9300			var msglen int
9301			for shift := uint(0); ; shift += 7 {
9302				if shift >= 64 {
9303					return ErrIntOverflowGenerated
9304				}
9305				if iNdEx >= l {
9306					return io.ErrUnexpectedEOF
9307				}
9308				b := dAtA[iNdEx]
9309				iNdEx++
9310				msglen |= (int(b) & 0x7F) << shift
9311				if b < 0x80 {
9312					break
9313				}
9314			}
9315			if msglen < 0 {
9316				return ErrInvalidLengthGenerated
9317			}
9318			postIndex := iNdEx + msglen
9319			if postIndex > l {
9320				return io.ErrUnexpectedEOF
9321			}
9322			m.Egress = append(m.Egress, NetworkPolicyEgressRule{})
9323			if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9324				return err
9325			}
9326			iNdEx = postIndex
9327		case 4:
9328			if wireType != 2 {
9329				return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType)
9330			}
9331			var stringLen uint64
9332			for shift := uint(0); ; shift += 7 {
9333				if shift >= 64 {
9334					return ErrIntOverflowGenerated
9335				}
9336				if iNdEx >= l {
9337					return io.ErrUnexpectedEOF
9338				}
9339				b := dAtA[iNdEx]
9340				iNdEx++
9341				stringLen |= (uint64(b) & 0x7F) << shift
9342				if b < 0x80 {
9343					break
9344				}
9345			}
9346			intStringLen := int(stringLen)
9347			if intStringLen < 0 {
9348				return ErrInvalidLengthGenerated
9349			}
9350			postIndex := iNdEx + intStringLen
9351			if postIndex > l {
9352				return io.ErrUnexpectedEOF
9353			}
9354			m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex]))
9355			iNdEx = postIndex
9356		default:
9357			iNdEx = preIndex
9358			skippy, err := skipGenerated(dAtA[iNdEx:])
9359			if err != nil {
9360				return err
9361			}
9362			if skippy < 0 {
9363				return ErrInvalidLengthGenerated
9364			}
9365			if (iNdEx + skippy) > l {
9366				return io.ErrUnexpectedEOF
9367			}
9368			iNdEx += skippy
9369		}
9370	}
9371
9372	if iNdEx > l {
9373		return io.ErrUnexpectedEOF
9374	}
9375	return nil
9376}
9377func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error {
9378	l := len(dAtA)
9379	iNdEx := 0
9380	for iNdEx < l {
9381		preIndex := iNdEx
9382		var wire uint64
9383		for shift := uint(0); ; shift += 7 {
9384			if shift >= 64 {
9385				return ErrIntOverflowGenerated
9386			}
9387			if iNdEx >= l {
9388				return io.ErrUnexpectedEOF
9389			}
9390			b := dAtA[iNdEx]
9391			iNdEx++
9392			wire |= (uint64(b) & 0x7F) << shift
9393			if b < 0x80 {
9394				break
9395			}
9396		}
9397		fieldNum := int32(wire >> 3)
9398		wireType := int(wire & 0x7)
9399		if wireType == 4 {
9400			return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group")
9401		}
9402		if fieldNum <= 0 {
9403			return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
9404		}
9405		switch fieldNum {
9406		case 1:
9407			if wireType != 2 {
9408				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
9409			}
9410			var msglen int
9411			for shift := uint(0); ; shift += 7 {
9412				if shift >= 64 {
9413					return ErrIntOverflowGenerated
9414				}
9415				if iNdEx >= l {
9416					return io.ErrUnexpectedEOF
9417				}
9418				b := dAtA[iNdEx]
9419				iNdEx++
9420				msglen |= (int(b) & 0x7F) << shift
9421				if b < 0x80 {
9422					break
9423				}
9424			}
9425			if msglen < 0 {
9426				return ErrInvalidLengthGenerated
9427			}
9428			postIndex := iNdEx + msglen
9429			if postIndex > l {
9430				return io.ErrUnexpectedEOF
9431			}
9432			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9433				return err
9434			}
9435			iNdEx = postIndex
9436		case 2:
9437			if wireType != 2 {
9438				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
9439			}
9440			var msglen int
9441			for shift := uint(0); ; shift += 7 {
9442				if shift >= 64 {
9443					return ErrIntOverflowGenerated
9444				}
9445				if iNdEx >= l {
9446					return io.ErrUnexpectedEOF
9447				}
9448				b := dAtA[iNdEx]
9449				iNdEx++
9450				msglen |= (int(b) & 0x7F) << shift
9451				if b < 0x80 {
9452					break
9453				}
9454			}
9455			if msglen < 0 {
9456				return ErrInvalidLengthGenerated
9457			}
9458			postIndex := iNdEx + msglen
9459			if postIndex > l {
9460				return io.ErrUnexpectedEOF
9461			}
9462			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9463				return err
9464			}
9465			iNdEx = postIndex
9466		default:
9467			iNdEx = preIndex
9468			skippy, err := skipGenerated(dAtA[iNdEx:])
9469			if err != nil {
9470				return err
9471			}
9472			if skippy < 0 {
9473				return ErrInvalidLengthGenerated
9474			}
9475			if (iNdEx + skippy) > l {
9476				return io.ErrUnexpectedEOF
9477			}
9478			iNdEx += skippy
9479		}
9480	}
9481
9482	if iNdEx > l {
9483		return io.ErrUnexpectedEOF
9484	}
9485	return nil
9486}
9487func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error {
9488	l := len(dAtA)
9489	iNdEx := 0
9490	for iNdEx < l {
9491		preIndex := iNdEx
9492		var wire uint64
9493		for shift := uint(0); ; shift += 7 {
9494			if shift >= 64 {
9495				return ErrIntOverflowGenerated
9496			}
9497			if iNdEx >= l {
9498				return io.ErrUnexpectedEOF
9499			}
9500			b := dAtA[iNdEx]
9501			iNdEx++
9502			wire |= (uint64(b) & 0x7F) << shift
9503			if b < 0x80 {
9504				break
9505			}
9506		}
9507		fieldNum := int32(wire >> 3)
9508		wireType := int(wire & 0x7)
9509		if wireType == 4 {
9510			return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group")
9511		}
9512		if fieldNum <= 0 {
9513			return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
9514		}
9515		switch fieldNum {
9516		case 1:
9517			if wireType != 2 {
9518				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
9519			}
9520			var msglen int
9521			for shift := uint(0); ; shift += 7 {
9522				if shift >= 64 {
9523					return ErrIntOverflowGenerated
9524				}
9525				if iNdEx >= l {
9526					return io.ErrUnexpectedEOF
9527				}
9528				b := dAtA[iNdEx]
9529				iNdEx++
9530				msglen |= (int(b) & 0x7F) << shift
9531				if b < 0x80 {
9532					break
9533				}
9534			}
9535			if msglen < 0 {
9536				return ErrInvalidLengthGenerated
9537			}
9538			postIndex := iNdEx + msglen
9539			if postIndex > l {
9540				return io.ErrUnexpectedEOF
9541			}
9542			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9543				return err
9544			}
9545			iNdEx = postIndex
9546		case 2:
9547			if wireType != 2 {
9548				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
9549			}
9550			var msglen int
9551			for shift := uint(0); ; shift += 7 {
9552				if shift >= 64 {
9553					return ErrIntOverflowGenerated
9554				}
9555				if iNdEx >= l {
9556					return io.ErrUnexpectedEOF
9557				}
9558				b := dAtA[iNdEx]
9559				iNdEx++
9560				msglen |= (int(b) & 0x7F) << shift
9561				if b < 0x80 {
9562					break
9563				}
9564			}
9565			if msglen < 0 {
9566				return ErrInvalidLengthGenerated
9567			}
9568			postIndex := iNdEx + msglen
9569			if postIndex > l {
9570				return io.ErrUnexpectedEOF
9571			}
9572			m.Items = append(m.Items, PodSecurityPolicy{})
9573			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9574				return err
9575			}
9576			iNdEx = postIndex
9577		default:
9578			iNdEx = preIndex
9579			skippy, err := skipGenerated(dAtA[iNdEx:])
9580			if err != nil {
9581				return err
9582			}
9583			if skippy < 0 {
9584				return ErrInvalidLengthGenerated
9585			}
9586			if (iNdEx + skippy) > l {
9587				return io.ErrUnexpectedEOF
9588			}
9589			iNdEx += skippy
9590		}
9591	}
9592
9593	if iNdEx > l {
9594		return io.ErrUnexpectedEOF
9595	}
9596	return nil
9597}
9598func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error {
9599	l := len(dAtA)
9600	iNdEx := 0
9601	for iNdEx < l {
9602		preIndex := iNdEx
9603		var wire uint64
9604		for shift := uint(0); ; shift += 7 {
9605			if shift >= 64 {
9606				return ErrIntOverflowGenerated
9607			}
9608			if iNdEx >= l {
9609				return io.ErrUnexpectedEOF
9610			}
9611			b := dAtA[iNdEx]
9612			iNdEx++
9613			wire |= (uint64(b) & 0x7F) << shift
9614			if b < 0x80 {
9615				break
9616			}
9617		}
9618		fieldNum := int32(wire >> 3)
9619		wireType := int(wire & 0x7)
9620		if wireType == 4 {
9621			return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group")
9622		}
9623		if fieldNum <= 0 {
9624			return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
9625		}
9626		switch fieldNum {
9627		case 1:
9628			if wireType != 0 {
9629				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
9630			}
9631			var v int
9632			for shift := uint(0); ; shift += 7 {
9633				if shift >= 64 {
9634					return ErrIntOverflowGenerated
9635				}
9636				if iNdEx >= l {
9637					return io.ErrUnexpectedEOF
9638				}
9639				b := dAtA[iNdEx]
9640				iNdEx++
9641				v |= (int(b) & 0x7F) << shift
9642				if b < 0x80 {
9643					break
9644				}
9645			}
9646			m.Privileged = bool(v != 0)
9647		case 2:
9648			if wireType != 2 {
9649				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
9650			}
9651			var stringLen uint64
9652			for shift := uint(0); ; shift += 7 {
9653				if shift >= 64 {
9654					return ErrIntOverflowGenerated
9655				}
9656				if iNdEx >= l {
9657					return io.ErrUnexpectedEOF
9658				}
9659				b := dAtA[iNdEx]
9660				iNdEx++
9661				stringLen |= (uint64(b) & 0x7F) << shift
9662				if b < 0x80 {
9663					break
9664				}
9665			}
9666			intStringLen := int(stringLen)
9667			if intStringLen < 0 {
9668				return ErrInvalidLengthGenerated
9669			}
9670			postIndex := iNdEx + intStringLen
9671			if postIndex > l {
9672				return io.ErrUnexpectedEOF
9673			}
9674			m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9675			iNdEx = postIndex
9676		case 3:
9677			if wireType != 2 {
9678				return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
9679			}
9680			var stringLen uint64
9681			for shift := uint(0); ; shift += 7 {
9682				if shift >= 64 {
9683					return ErrIntOverflowGenerated
9684				}
9685				if iNdEx >= l {
9686					return io.ErrUnexpectedEOF
9687				}
9688				b := dAtA[iNdEx]
9689				iNdEx++
9690				stringLen |= (uint64(b) & 0x7F) << shift
9691				if b < 0x80 {
9692					break
9693				}
9694			}
9695			intStringLen := int(stringLen)
9696			if intStringLen < 0 {
9697				return ErrInvalidLengthGenerated
9698			}
9699			postIndex := iNdEx + intStringLen
9700			if postIndex > l {
9701				return io.ErrUnexpectedEOF
9702			}
9703			m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9704			iNdEx = postIndex
9705		case 4:
9706			if wireType != 2 {
9707				return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
9708			}
9709			var stringLen uint64
9710			for shift := uint(0); ; shift += 7 {
9711				if shift >= 64 {
9712					return ErrIntOverflowGenerated
9713				}
9714				if iNdEx >= l {
9715					return io.ErrUnexpectedEOF
9716				}
9717				b := dAtA[iNdEx]
9718				iNdEx++
9719				stringLen |= (uint64(b) & 0x7F) << shift
9720				if b < 0x80 {
9721					break
9722				}
9723			}
9724			intStringLen := int(stringLen)
9725			if intStringLen < 0 {
9726				return ErrInvalidLengthGenerated
9727			}
9728			postIndex := iNdEx + intStringLen
9729			if postIndex > l {
9730				return io.ErrUnexpectedEOF
9731			}
9732			m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9733			iNdEx = postIndex
9734		case 5:
9735			if wireType != 2 {
9736				return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
9737			}
9738			var stringLen uint64
9739			for shift := uint(0); ; shift += 7 {
9740				if shift >= 64 {
9741					return ErrIntOverflowGenerated
9742				}
9743				if iNdEx >= l {
9744					return io.ErrUnexpectedEOF
9745				}
9746				b := dAtA[iNdEx]
9747				iNdEx++
9748				stringLen |= (uint64(b) & 0x7F) << shift
9749				if b < 0x80 {
9750					break
9751				}
9752			}
9753			intStringLen := int(stringLen)
9754			if intStringLen < 0 {
9755				return ErrInvalidLengthGenerated
9756			}
9757			postIndex := iNdEx + intStringLen
9758			if postIndex > l {
9759				return io.ErrUnexpectedEOF
9760			}
9761			m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex]))
9762			iNdEx = postIndex
9763		case 6:
9764			if wireType != 0 {
9765				return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
9766			}
9767			var v int
9768			for shift := uint(0); ; shift += 7 {
9769				if shift >= 64 {
9770					return ErrIntOverflowGenerated
9771				}
9772				if iNdEx >= l {
9773					return io.ErrUnexpectedEOF
9774				}
9775				b := dAtA[iNdEx]
9776				iNdEx++
9777				v |= (int(b) & 0x7F) << shift
9778				if b < 0x80 {
9779					break
9780				}
9781			}
9782			m.HostNetwork = bool(v != 0)
9783		case 7:
9784			if wireType != 2 {
9785				return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType)
9786			}
9787			var msglen int
9788			for shift := uint(0); ; shift += 7 {
9789				if shift >= 64 {
9790					return ErrIntOverflowGenerated
9791				}
9792				if iNdEx >= l {
9793					return io.ErrUnexpectedEOF
9794				}
9795				b := dAtA[iNdEx]
9796				iNdEx++
9797				msglen |= (int(b) & 0x7F) << shift
9798				if b < 0x80 {
9799					break
9800				}
9801			}
9802			if msglen < 0 {
9803				return ErrInvalidLengthGenerated
9804			}
9805			postIndex := iNdEx + msglen
9806			if postIndex > l {
9807				return io.ErrUnexpectedEOF
9808			}
9809			m.HostPorts = append(m.HostPorts, HostPortRange{})
9810			if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9811				return err
9812			}
9813			iNdEx = postIndex
9814		case 8:
9815			if wireType != 0 {
9816				return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
9817			}
9818			var v int
9819			for shift := uint(0); ; shift += 7 {
9820				if shift >= 64 {
9821					return ErrIntOverflowGenerated
9822				}
9823				if iNdEx >= l {
9824					return io.ErrUnexpectedEOF
9825				}
9826				b := dAtA[iNdEx]
9827				iNdEx++
9828				v |= (int(b) & 0x7F) << shift
9829				if b < 0x80 {
9830					break
9831				}
9832			}
9833			m.HostPID = bool(v != 0)
9834		case 9:
9835			if wireType != 0 {
9836				return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
9837			}
9838			var v int
9839			for shift := uint(0); ; shift += 7 {
9840				if shift >= 64 {
9841					return ErrIntOverflowGenerated
9842				}
9843				if iNdEx >= l {
9844					return io.ErrUnexpectedEOF
9845				}
9846				b := dAtA[iNdEx]
9847				iNdEx++
9848				v |= (int(b) & 0x7F) << shift
9849				if b < 0x80 {
9850					break
9851				}
9852			}
9853			m.HostIPC = bool(v != 0)
9854		case 10:
9855			if wireType != 2 {
9856				return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType)
9857			}
9858			var msglen int
9859			for shift := uint(0); ; shift += 7 {
9860				if shift >= 64 {
9861					return ErrIntOverflowGenerated
9862				}
9863				if iNdEx >= l {
9864					return io.ErrUnexpectedEOF
9865				}
9866				b := dAtA[iNdEx]
9867				iNdEx++
9868				msglen |= (int(b) & 0x7F) << shift
9869				if b < 0x80 {
9870					break
9871				}
9872			}
9873			if msglen < 0 {
9874				return ErrInvalidLengthGenerated
9875			}
9876			postIndex := iNdEx + msglen
9877			if postIndex > l {
9878				return io.ErrUnexpectedEOF
9879			}
9880			if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9881				return err
9882			}
9883			iNdEx = postIndex
9884		case 11:
9885			if wireType != 2 {
9886				return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
9887			}
9888			var msglen int
9889			for shift := uint(0); ; shift += 7 {
9890				if shift >= 64 {
9891					return ErrIntOverflowGenerated
9892				}
9893				if iNdEx >= l {
9894					return io.ErrUnexpectedEOF
9895				}
9896				b := dAtA[iNdEx]
9897				iNdEx++
9898				msglen |= (int(b) & 0x7F) << shift
9899				if b < 0x80 {
9900					break
9901				}
9902			}
9903			if msglen < 0 {
9904				return ErrInvalidLengthGenerated
9905			}
9906			postIndex := iNdEx + msglen
9907			if postIndex > l {
9908				return io.ErrUnexpectedEOF
9909			}
9910			if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9911				return err
9912			}
9913			iNdEx = postIndex
9914		case 12:
9915			if wireType != 2 {
9916				return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
9917			}
9918			var msglen int
9919			for shift := uint(0); ; shift += 7 {
9920				if shift >= 64 {
9921					return ErrIntOverflowGenerated
9922				}
9923				if iNdEx >= l {
9924					return io.ErrUnexpectedEOF
9925				}
9926				b := dAtA[iNdEx]
9927				iNdEx++
9928				msglen |= (int(b) & 0x7F) << shift
9929				if b < 0x80 {
9930					break
9931				}
9932			}
9933			if msglen < 0 {
9934				return ErrInvalidLengthGenerated
9935			}
9936			postIndex := iNdEx + msglen
9937			if postIndex > l {
9938				return io.ErrUnexpectedEOF
9939			}
9940			if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9941				return err
9942			}
9943			iNdEx = postIndex
9944		case 13:
9945			if wireType != 2 {
9946				return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
9947			}
9948			var msglen int
9949			for shift := uint(0); ; shift += 7 {
9950				if shift >= 64 {
9951					return ErrIntOverflowGenerated
9952				}
9953				if iNdEx >= l {
9954					return io.ErrUnexpectedEOF
9955				}
9956				b := dAtA[iNdEx]
9957				iNdEx++
9958				msglen |= (int(b) & 0x7F) << shift
9959				if b < 0x80 {
9960					break
9961				}
9962			}
9963			if msglen < 0 {
9964				return ErrInvalidLengthGenerated
9965			}
9966			postIndex := iNdEx + msglen
9967			if postIndex > l {
9968				return io.ErrUnexpectedEOF
9969			}
9970			if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9971				return err
9972			}
9973			iNdEx = postIndex
9974		case 14:
9975			if wireType != 0 {
9976				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
9977			}
9978			var v int
9979			for shift := uint(0); ; shift += 7 {
9980				if shift >= 64 {
9981					return ErrIntOverflowGenerated
9982				}
9983				if iNdEx >= l {
9984					return io.ErrUnexpectedEOF
9985				}
9986				b := dAtA[iNdEx]
9987				iNdEx++
9988				v |= (int(b) & 0x7F) << shift
9989				if b < 0x80 {
9990					break
9991				}
9992			}
9993			m.ReadOnlyRootFilesystem = bool(v != 0)
9994		case 15:
9995			if wireType != 0 {
9996				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType)
9997			}
9998			var v int
9999			for shift := uint(0); ; shift += 7 {
10000				if shift >= 64 {
10001					return ErrIntOverflowGenerated
10002				}
10003				if iNdEx >= l {
10004					return io.ErrUnexpectedEOF
10005				}
10006				b := dAtA[iNdEx]
10007				iNdEx++
10008				v |= (int(b) & 0x7F) << shift
10009				if b < 0x80 {
10010					break
10011				}
10012			}
10013			b := bool(v != 0)
10014			m.DefaultAllowPrivilegeEscalation = &b
10015		case 16:
10016			if wireType != 0 {
10017				return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType)
10018			}
10019			var v int
10020			for shift := uint(0); ; shift += 7 {
10021				if shift >= 64 {
10022					return ErrIntOverflowGenerated
10023				}
10024				if iNdEx >= l {
10025					return io.ErrUnexpectedEOF
10026				}
10027				b := dAtA[iNdEx]
10028				iNdEx++
10029				v |= (int(b) & 0x7F) << shift
10030				if b < 0x80 {
10031					break
10032				}
10033			}
10034			b := bool(v != 0)
10035			m.AllowPrivilegeEscalation = &b
10036		case 17:
10037			if wireType != 2 {
10038				return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType)
10039			}
10040			var msglen int
10041			for shift := uint(0); ; shift += 7 {
10042				if shift >= 64 {
10043					return ErrIntOverflowGenerated
10044				}
10045				if iNdEx >= l {
10046					return io.ErrUnexpectedEOF
10047				}
10048				b := dAtA[iNdEx]
10049				iNdEx++
10050				msglen |= (int(b) & 0x7F) << shift
10051				if b < 0x80 {
10052					break
10053				}
10054			}
10055			if msglen < 0 {
10056				return ErrInvalidLengthGenerated
10057			}
10058			postIndex := iNdEx + msglen
10059			if postIndex > l {
10060				return io.ErrUnexpectedEOF
10061			}
10062			m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{})
10063			if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10064				return err
10065			}
10066			iNdEx = postIndex
10067		case 18:
10068			if wireType != 2 {
10069				return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType)
10070			}
10071			var msglen int
10072			for shift := uint(0); ; shift += 7 {
10073				if shift >= 64 {
10074					return ErrIntOverflowGenerated
10075				}
10076				if iNdEx >= l {
10077					return io.ErrUnexpectedEOF
10078				}
10079				b := dAtA[iNdEx]
10080				iNdEx++
10081				msglen |= (int(b) & 0x7F) << shift
10082				if b < 0x80 {
10083					break
10084				}
10085			}
10086			if msglen < 0 {
10087				return ErrInvalidLengthGenerated
10088			}
10089			postIndex := iNdEx + msglen
10090			if postIndex > l {
10091				return io.ErrUnexpectedEOF
10092			}
10093			m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{})
10094			if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10095				return err
10096			}
10097			iNdEx = postIndex
10098		case 19:
10099			if wireType != 2 {
10100				return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType)
10101			}
10102			var stringLen uint64
10103			for shift := uint(0); ; shift += 7 {
10104				if shift >= 64 {
10105					return ErrIntOverflowGenerated
10106				}
10107				if iNdEx >= l {
10108					return io.ErrUnexpectedEOF
10109				}
10110				b := dAtA[iNdEx]
10111				iNdEx++
10112				stringLen |= (uint64(b) & 0x7F) << shift
10113				if b < 0x80 {
10114					break
10115				}
10116			}
10117			intStringLen := int(stringLen)
10118			if intStringLen < 0 {
10119				return ErrInvalidLengthGenerated
10120			}
10121			postIndex := iNdEx + intStringLen
10122			if postIndex > l {
10123				return io.ErrUnexpectedEOF
10124			}
10125			m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex]))
10126			iNdEx = postIndex
10127		case 20:
10128			if wireType != 2 {
10129				return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType)
10130			}
10131			var stringLen uint64
10132			for shift := uint(0); ; shift += 7 {
10133				if shift >= 64 {
10134					return ErrIntOverflowGenerated
10135				}
10136				if iNdEx >= l {
10137					return io.ErrUnexpectedEOF
10138				}
10139				b := dAtA[iNdEx]
10140				iNdEx++
10141				stringLen |= (uint64(b) & 0x7F) << shift
10142				if b < 0x80 {
10143					break
10144				}
10145			}
10146			intStringLen := int(stringLen)
10147			if intStringLen < 0 {
10148				return ErrInvalidLengthGenerated
10149			}
10150			postIndex := iNdEx + intStringLen
10151			if postIndex > l {
10152				return io.ErrUnexpectedEOF
10153			}
10154			m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex]))
10155			iNdEx = postIndex
10156		case 21:
10157			if wireType != 2 {
10158				return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType)
10159			}
10160			var stringLen uint64
10161			for shift := uint(0); ; shift += 7 {
10162				if shift >= 64 {
10163					return ErrIntOverflowGenerated
10164				}
10165				if iNdEx >= l {
10166					return io.ErrUnexpectedEOF
10167				}
10168				b := dAtA[iNdEx]
10169				iNdEx++
10170				stringLen |= (uint64(b) & 0x7F) << shift
10171				if b < 0x80 {
10172					break
10173				}
10174			}
10175			intStringLen := int(stringLen)
10176			if intStringLen < 0 {
10177				return ErrInvalidLengthGenerated
10178			}
10179			postIndex := iNdEx + intStringLen
10180			if postIndex > l {
10181				return io.ErrUnexpectedEOF
10182			}
10183			m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex]))
10184			iNdEx = postIndex
10185		case 22:
10186			if wireType != 2 {
10187				return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType)
10188			}
10189			var msglen int
10190			for shift := uint(0); ; shift += 7 {
10191				if shift >= 64 {
10192					return ErrIntOverflowGenerated
10193				}
10194				if iNdEx >= l {
10195					return io.ErrUnexpectedEOF
10196				}
10197				b := dAtA[iNdEx]
10198				iNdEx++
10199				msglen |= (int(b) & 0x7F) << shift
10200				if b < 0x80 {
10201					break
10202				}
10203			}
10204			if msglen < 0 {
10205				return ErrInvalidLengthGenerated
10206			}
10207			postIndex := iNdEx + msglen
10208			if postIndex > l {
10209				return io.ErrUnexpectedEOF
10210			}
10211			if m.RunAsGroup == nil {
10212				m.RunAsGroup = &RunAsGroupStrategyOptions{}
10213			}
10214			if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10215				return err
10216			}
10217			iNdEx = postIndex
10218		case 23:
10219			if wireType != 2 {
10220				return fmt.Errorf("proto: wrong wireType = %d for field AllowedCSIDrivers", wireType)
10221			}
10222			var msglen int
10223			for shift := uint(0); ; shift += 7 {
10224				if shift >= 64 {
10225					return ErrIntOverflowGenerated
10226				}
10227				if iNdEx >= l {
10228					return io.ErrUnexpectedEOF
10229				}
10230				b := dAtA[iNdEx]
10231				iNdEx++
10232				msglen |= (int(b) & 0x7F) << shift
10233				if b < 0x80 {
10234					break
10235				}
10236			}
10237			if msglen < 0 {
10238				return ErrInvalidLengthGenerated
10239			}
10240			postIndex := iNdEx + msglen
10241			if postIndex > l {
10242				return io.ErrUnexpectedEOF
10243			}
10244			m.AllowedCSIDrivers = append(m.AllowedCSIDrivers, AllowedCSIDriver{})
10245			if err := m.AllowedCSIDrivers[len(m.AllowedCSIDrivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10246				return err
10247			}
10248			iNdEx = postIndex
10249		case 24:
10250			if wireType != 2 {
10251				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeClass", wireType)
10252			}
10253			var msglen int
10254			for shift := uint(0); ; shift += 7 {
10255				if shift >= 64 {
10256					return ErrIntOverflowGenerated
10257				}
10258				if iNdEx >= l {
10259					return io.ErrUnexpectedEOF
10260				}
10261				b := dAtA[iNdEx]
10262				iNdEx++
10263				msglen |= (int(b) & 0x7F) << shift
10264				if b < 0x80 {
10265					break
10266				}
10267			}
10268			if msglen < 0 {
10269				return ErrInvalidLengthGenerated
10270			}
10271			postIndex := iNdEx + msglen
10272			if postIndex > l {
10273				return io.ErrUnexpectedEOF
10274			}
10275			if m.RuntimeClass == nil {
10276				m.RuntimeClass = &RuntimeClassStrategyOptions{}
10277			}
10278			if err := m.RuntimeClass.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10279				return err
10280			}
10281			iNdEx = postIndex
10282		default:
10283			iNdEx = preIndex
10284			skippy, err := skipGenerated(dAtA[iNdEx:])
10285			if err != nil {
10286				return err
10287			}
10288			if skippy < 0 {
10289				return ErrInvalidLengthGenerated
10290			}
10291			if (iNdEx + skippy) > l {
10292				return io.ErrUnexpectedEOF
10293			}
10294			iNdEx += skippy
10295		}
10296	}
10297
10298	if iNdEx > l {
10299		return io.ErrUnexpectedEOF
10300	}
10301	return nil
10302}
10303func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
10304	l := len(dAtA)
10305	iNdEx := 0
10306	for iNdEx < l {
10307		preIndex := iNdEx
10308		var wire uint64
10309		for shift := uint(0); ; shift += 7 {
10310			if shift >= 64 {
10311				return ErrIntOverflowGenerated
10312			}
10313			if iNdEx >= l {
10314				return io.ErrUnexpectedEOF
10315			}
10316			b := dAtA[iNdEx]
10317			iNdEx++
10318			wire |= (uint64(b) & 0x7F) << shift
10319			if b < 0x80 {
10320				break
10321			}
10322		}
10323		fieldNum := int32(wire >> 3)
10324		wireType := int(wire & 0x7)
10325		if wireType == 4 {
10326			return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
10327		}
10328		if fieldNum <= 0 {
10329			return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
10330		}
10331		switch fieldNum {
10332		case 1:
10333			if wireType != 2 {
10334				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
10335			}
10336			var msglen int
10337			for shift := uint(0); ; shift += 7 {
10338				if shift >= 64 {
10339					return ErrIntOverflowGenerated
10340				}
10341				if iNdEx >= l {
10342					return io.ErrUnexpectedEOF
10343				}
10344				b := dAtA[iNdEx]
10345				iNdEx++
10346				msglen |= (int(b) & 0x7F) << shift
10347				if b < 0x80 {
10348					break
10349				}
10350			}
10351			if msglen < 0 {
10352				return ErrInvalidLengthGenerated
10353			}
10354			postIndex := iNdEx + msglen
10355			if postIndex > l {
10356				return io.ErrUnexpectedEOF
10357			}
10358			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10359				return err
10360			}
10361			iNdEx = postIndex
10362		case 2:
10363			if wireType != 2 {
10364				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
10365			}
10366			var msglen int
10367			for shift := uint(0); ; shift += 7 {
10368				if shift >= 64 {
10369					return ErrIntOverflowGenerated
10370				}
10371				if iNdEx >= l {
10372					return io.ErrUnexpectedEOF
10373				}
10374				b := dAtA[iNdEx]
10375				iNdEx++
10376				msglen |= (int(b) & 0x7F) << shift
10377				if b < 0x80 {
10378					break
10379				}
10380			}
10381			if msglen < 0 {
10382				return ErrInvalidLengthGenerated
10383			}
10384			postIndex := iNdEx + msglen
10385			if postIndex > l {
10386				return io.ErrUnexpectedEOF
10387			}
10388			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10389				return err
10390			}
10391			iNdEx = postIndex
10392		case 3:
10393			if wireType != 2 {
10394				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10395			}
10396			var msglen int
10397			for shift := uint(0); ; shift += 7 {
10398				if shift >= 64 {
10399					return ErrIntOverflowGenerated
10400				}
10401				if iNdEx >= l {
10402					return io.ErrUnexpectedEOF
10403				}
10404				b := dAtA[iNdEx]
10405				iNdEx++
10406				msglen |= (int(b) & 0x7F) << shift
10407				if b < 0x80 {
10408					break
10409				}
10410			}
10411			if msglen < 0 {
10412				return ErrInvalidLengthGenerated
10413			}
10414			postIndex := iNdEx + msglen
10415			if postIndex > l {
10416				return io.ErrUnexpectedEOF
10417			}
10418			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10419				return err
10420			}
10421			iNdEx = postIndex
10422		default:
10423			iNdEx = preIndex
10424			skippy, err := skipGenerated(dAtA[iNdEx:])
10425			if err != nil {
10426				return err
10427			}
10428			if skippy < 0 {
10429				return ErrInvalidLengthGenerated
10430			}
10431			if (iNdEx + skippy) > l {
10432				return io.ErrUnexpectedEOF
10433			}
10434			iNdEx += skippy
10435		}
10436	}
10437
10438	if iNdEx > l {
10439		return io.ErrUnexpectedEOF
10440	}
10441	return nil
10442}
10443func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
10444	l := len(dAtA)
10445	iNdEx := 0
10446	for iNdEx < l {
10447		preIndex := iNdEx
10448		var wire uint64
10449		for shift := uint(0); ; shift += 7 {
10450			if shift >= 64 {
10451				return ErrIntOverflowGenerated
10452			}
10453			if iNdEx >= l {
10454				return io.ErrUnexpectedEOF
10455			}
10456			b := dAtA[iNdEx]
10457			iNdEx++
10458			wire |= (uint64(b) & 0x7F) << shift
10459			if b < 0x80 {
10460				break
10461			}
10462		}
10463		fieldNum := int32(wire >> 3)
10464		wireType := int(wire & 0x7)
10465		if wireType == 4 {
10466			return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
10467		}
10468		if fieldNum <= 0 {
10469			return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
10470		}
10471		switch fieldNum {
10472		case 1:
10473			if wireType != 2 {
10474				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
10475			}
10476			var stringLen uint64
10477			for shift := uint(0); ; shift += 7 {
10478				if shift >= 64 {
10479					return ErrIntOverflowGenerated
10480				}
10481				if iNdEx >= l {
10482					return io.ErrUnexpectedEOF
10483				}
10484				b := dAtA[iNdEx]
10485				iNdEx++
10486				stringLen |= (uint64(b) & 0x7F) << shift
10487				if b < 0x80 {
10488					break
10489				}
10490			}
10491			intStringLen := int(stringLen)
10492			if intStringLen < 0 {
10493				return ErrInvalidLengthGenerated
10494			}
10495			postIndex := iNdEx + intStringLen
10496			if postIndex > l {
10497				return io.ErrUnexpectedEOF
10498			}
10499			m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
10500			iNdEx = postIndex
10501		case 2:
10502			if wireType != 2 {
10503				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10504			}
10505			var stringLen uint64
10506			for shift := uint(0); ; shift += 7 {
10507				if shift >= 64 {
10508					return ErrIntOverflowGenerated
10509				}
10510				if iNdEx >= l {
10511					return io.ErrUnexpectedEOF
10512				}
10513				b := dAtA[iNdEx]
10514				iNdEx++
10515				stringLen |= (uint64(b) & 0x7F) << shift
10516				if b < 0x80 {
10517					break
10518				}
10519			}
10520			intStringLen := int(stringLen)
10521			if intStringLen < 0 {
10522				return ErrInvalidLengthGenerated
10523			}
10524			postIndex := iNdEx + intStringLen
10525			if postIndex > l {
10526				return io.ErrUnexpectedEOF
10527			}
10528			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
10529			iNdEx = postIndex
10530		case 3:
10531			if wireType != 2 {
10532				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
10533			}
10534			var msglen int
10535			for shift := uint(0); ; shift += 7 {
10536				if shift >= 64 {
10537					return ErrIntOverflowGenerated
10538				}
10539				if iNdEx >= l {
10540					return io.ErrUnexpectedEOF
10541				}
10542				b := dAtA[iNdEx]
10543				iNdEx++
10544				msglen |= (int(b) & 0x7F) << shift
10545				if b < 0x80 {
10546					break
10547				}
10548			}
10549			if msglen < 0 {
10550				return ErrInvalidLengthGenerated
10551			}
10552			postIndex := iNdEx + msglen
10553			if postIndex > l {
10554				return io.ErrUnexpectedEOF
10555			}
10556			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10557				return err
10558			}
10559			iNdEx = postIndex
10560		case 4:
10561			if wireType != 2 {
10562				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
10563			}
10564			var stringLen uint64
10565			for shift := uint(0); ; shift += 7 {
10566				if shift >= 64 {
10567					return ErrIntOverflowGenerated
10568				}
10569				if iNdEx >= l {
10570					return io.ErrUnexpectedEOF
10571				}
10572				b := dAtA[iNdEx]
10573				iNdEx++
10574				stringLen |= (uint64(b) & 0x7F) << shift
10575				if b < 0x80 {
10576					break
10577				}
10578			}
10579			intStringLen := int(stringLen)
10580			if intStringLen < 0 {
10581				return ErrInvalidLengthGenerated
10582			}
10583			postIndex := iNdEx + intStringLen
10584			if postIndex > l {
10585				return io.ErrUnexpectedEOF
10586			}
10587			m.Reason = string(dAtA[iNdEx:postIndex])
10588			iNdEx = postIndex
10589		case 5:
10590			if wireType != 2 {
10591				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
10592			}
10593			var stringLen uint64
10594			for shift := uint(0); ; shift += 7 {
10595				if shift >= 64 {
10596					return ErrIntOverflowGenerated
10597				}
10598				if iNdEx >= l {
10599					return io.ErrUnexpectedEOF
10600				}
10601				b := dAtA[iNdEx]
10602				iNdEx++
10603				stringLen |= (uint64(b) & 0x7F) << shift
10604				if b < 0x80 {
10605					break
10606				}
10607			}
10608			intStringLen := int(stringLen)
10609			if intStringLen < 0 {
10610				return ErrInvalidLengthGenerated
10611			}
10612			postIndex := iNdEx + intStringLen
10613			if postIndex > l {
10614				return io.ErrUnexpectedEOF
10615			}
10616			m.Message = string(dAtA[iNdEx:postIndex])
10617			iNdEx = postIndex
10618		default:
10619			iNdEx = preIndex
10620			skippy, err := skipGenerated(dAtA[iNdEx:])
10621			if err != nil {
10622				return err
10623			}
10624			if skippy < 0 {
10625				return ErrInvalidLengthGenerated
10626			}
10627			if (iNdEx + skippy) > l {
10628				return io.ErrUnexpectedEOF
10629			}
10630			iNdEx += skippy
10631		}
10632	}
10633
10634	if iNdEx > l {
10635		return io.ErrUnexpectedEOF
10636	}
10637	return nil
10638}
10639func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
10640	l := len(dAtA)
10641	iNdEx := 0
10642	for iNdEx < l {
10643		preIndex := iNdEx
10644		var wire uint64
10645		for shift := uint(0); ; shift += 7 {
10646			if shift >= 64 {
10647				return ErrIntOverflowGenerated
10648			}
10649			if iNdEx >= l {
10650				return io.ErrUnexpectedEOF
10651			}
10652			b := dAtA[iNdEx]
10653			iNdEx++
10654			wire |= (uint64(b) & 0x7F) << shift
10655			if b < 0x80 {
10656				break
10657			}
10658		}
10659		fieldNum := int32(wire >> 3)
10660		wireType := int(wire & 0x7)
10661		if wireType == 4 {
10662			return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
10663		}
10664		if fieldNum <= 0 {
10665			return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
10666		}
10667		switch fieldNum {
10668		case 1:
10669			if wireType != 2 {
10670				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
10671			}
10672			var msglen int
10673			for shift := uint(0); ; shift += 7 {
10674				if shift >= 64 {
10675					return ErrIntOverflowGenerated
10676				}
10677				if iNdEx >= l {
10678					return io.ErrUnexpectedEOF
10679				}
10680				b := dAtA[iNdEx]
10681				iNdEx++
10682				msglen |= (int(b) & 0x7F) << shift
10683				if b < 0x80 {
10684					break
10685				}
10686			}
10687			if msglen < 0 {
10688				return ErrInvalidLengthGenerated
10689			}
10690			postIndex := iNdEx + msglen
10691			if postIndex > l {
10692				return io.ErrUnexpectedEOF
10693			}
10694			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10695				return err
10696			}
10697			iNdEx = postIndex
10698		case 2:
10699			if wireType != 2 {
10700				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
10701			}
10702			var msglen int
10703			for shift := uint(0); ; shift += 7 {
10704				if shift >= 64 {
10705					return ErrIntOverflowGenerated
10706				}
10707				if iNdEx >= l {
10708					return io.ErrUnexpectedEOF
10709				}
10710				b := dAtA[iNdEx]
10711				iNdEx++
10712				msglen |= (int(b) & 0x7F) << shift
10713				if b < 0x80 {
10714					break
10715				}
10716			}
10717			if msglen < 0 {
10718				return ErrInvalidLengthGenerated
10719			}
10720			postIndex := iNdEx + msglen
10721			if postIndex > l {
10722				return io.ErrUnexpectedEOF
10723			}
10724			m.Items = append(m.Items, ReplicaSet{})
10725			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10726				return err
10727			}
10728			iNdEx = postIndex
10729		default:
10730			iNdEx = preIndex
10731			skippy, err := skipGenerated(dAtA[iNdEx:])
10732			if err != nil {
10733				return err
10734			}
10735			if skippy < 0 {
10736				return ErrInvalidLengthGenerated
10737			}
10738			if (iNdEx + skippy) > l {
10739				return io.ErrUnexpectedEOF
10740			}
10741			iNdEx += skippy
10742		}
10743	}
10744
10745	if iNdEx > l {
10746		return io.ErrUnexpectedEOF
10747	}
10748	return nil
10749}
10750func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
10751	l := len(dAtA)
10752	iNdEx := 0
10753	for iNdEx < l {
10754		preIndex := iNdEx
10755		var wire uint64
10756		for shift := uint(0); ; shift += 7 {
10757			if shift >= 64 {
10758				return ErrIntOverflowGenerated
10759			}
10760			if iNdEx >= l {
10761				return io.ErrUnexpectedEOF
10762			}
10763			b := dAtA[iNdEx]
10764			iNdEx++
10765			wire |= (uint64(b) & 0x7F) << shift
10766			if b < 0x80 {
10767				break
10768			}
10769		}
10770		fieldNum := int32(wire >> 3)
10771		wireType := int(wire & 0x7)
10772		if wireType == 4 {
10773			return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
10774		}
10775		if fieldNum <= 0 {
10776			return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
10777		}
10778		switch fieldNum {
10779		case 1:
10780			if wireType != 0 {
10781				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10782			}
10783			var v int32
10784			for shift := uint(0); ; shift += 7 {
10785				if shift >= 64 {
10786					return ErrIntOverflowGenerated
10787				}
10788				if iNdEx >= l {
10789					return io.ErrUnexpectedEOF
10790				}
10791				b := dAtA[iNdEx]
10792				iNdEx++
10793				v |= (int32(b) & 0x7F) << shift
10794				if b < 0x80 {
10795					break
10796				}
10797			}
10798			m.Replicas = &v
10799		case 2:
10800			if wireType != 2 {
10801				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
10802			}
10803			var msglen int
10804			for shift := uint(0); ; shift += 7 {
10805				if shift >= 64 {
10806					return ErrIntOverflowGenerated
10807				}
10808				if iNdEx >= l {
10809					return io.ErrUnexpectedEOF
10810				}
10811				b := dAtA[iNdEx]
10812				iNdEx++
10813				msglen |= (int(b) & 0x7F) << shift
10814				if b < 0x80 {
10815					break
10816				}
10817			}
10818			if msglen < 0 {
10819				return ErrInvalidLengthGenerated
10820			}
10821			postIndex := iNdEx + msglen
10822			if postIndex > l {
10823				return io.ErrUnexpectedEOF
10824			}
10825			if m.Selector == nil {
10826				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
10827			}
10828			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10829				return err
10830			}
10831			iNdEx = postIndex
10832		case 3:
10833			if wireType != 2 {
10834				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
10835			}
10836			var msglen int
10837			for shift := uint(0); ; shift += 7 {
10838				if shift >= 64 {
10839					return ErrIntOverflowGenerated
10840				}
10841				if iNdEx >= l {
10842					return io.ErrUnexpectedEOF
10843				}
10844				b := dAtA[iNdEx]
10845				iNdEx++
10846				msglen |= (int(b) & 0x7F) << shift
10847				if b < 0x80 {
10848					break
10849				}
10850			}
10851			if msglen < 0 {
10852				return ErrInvalidLengthGenerated
10853			}
10854			postIndex := iNdEx + msglen
10855			if postIndex > l {
10856				return io.ErrUnexpectedEOF
10857			}
10858			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10859				return err
10860			}
10861			iNdEx = postIndex
10862		case 4:
10863			if wireType != 0 {
10864				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
10865			}
10866			m.MinReadySeconds = 0
10867			for shift := uint(0); ; shift += 7 {
10868				if shift >= 64 {
10869					return ErrIntOverflowGenerated
10870				}
10871				if iNdEx >= l {
10872					return io.ErrUnexpectedEOF
10873				}
10874				b := dAtA[iNdEx]
10875				iNdEx++
10876				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
10877				if b < 0x80 {
10878					break
10879				}
10880			}
10881		default:
10882			iNdEx = preIndex
10883			skippy, err := skipGenerated(dAtA[iNdEx:])
10884			if err != nil {
10885				return err
10886			}
10887			if skippy < 0 {
10888				return ErrInvalidLengthGenerated
10889			}
10890			if (iNdEx + skippy) > l {
10891				return io.ErrUnexpectedEOF
10892			}
10893			iNdEx += skippy
10894		}
10895	}
10896
10897	if iNdEx > l {
10898		return io.ErrUnexpectedEOF
10899	}
10900	return nil
10901}
10902func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
10903	l := len(dAtA)
10904	iNdEx := 0
10905	for iNdEx < l {
10906		preIndex := iNdEx
10907		var wire uint64
10908		for shift := uint(0); ; shift += 7 {
10909			if shift >= 64 {
10910				return ErrIntOverflowGenerated
10911			}
10912			if iNdEx >= l {
10913				return io.ErrUnexpectedEOF
10914			}
10915			b := dAtA[iNdEx]
10916			iNdEx++
10917			wire |= (uint64(b) & 0x7F) << shift
10918			if b < 0x80 {
10919				break
10920			}
10921		}
10922		fieldNum := int32(wire >> 3)
10923		wireType := int(wire & 0x7)
10924		if wireType == 4 {
10925			return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
10926		}
10927		if fieldNum <= 0 {
10928			return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
10929		}
10930		switch fieldNum {
10931		case 1:
10932			if wireType != 0 {
10933				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10934			}
10935			m.Replicas = 0
10936			for shift := uint(0); ; shift += 7 {
10937				if shift >= 64 {
10938					return ErrIntOverflowGenerated
10939				}
10940				if iNdEx >= l {
10941					return io.ErrUnexpectedEOF
10942				}
10943				b := dAtA[iNdEx]
10944				iNdEx++
10945				m.Replicas |= (int32(b) & 0x7F) << shift
10946				if b < 0x80 {
10947					break
10948				}
10949			}
10950		case 2:
10951			if wireType != 0 {
10952				return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
10953			}
10954			m.FullyLabeledReplicas = 0
10955			for shift := uint(0); ; shift += 7 {
10956				if shift >= 64 {
10957					return ErrIntOverflowGenerated
10958				}
10959				if iNdEx >= l {
10960					return io.ErrUnexpectedEOF
10961				}
10962				b := dAtA[iNdEx]
10963				iNdEx++
10964				m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
10965				if b < 0x80 {
10966					break
10967				}
10968			}
10969		case 3:
10970			if wireType != 0 {
10971				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
10972			}
10973			m.ObservedGeneration = 0
10974			for shift := uint(0); ; shift += 7 {
10975				if shift >= 64 {
10976					return ErrIntOverflowGenerated
10977				}
10978				if iNdEx >= l {
10979					return io.ErrUnexpectedEOF
10980				}
10981				b := dAtA[iNdEx]
10982				iNdEx++
10983				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
10984				if b < 0x80 {
10985					break
10986				}
10987			}
10988		case 4:
10989			if wireType != 0 {
10990				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
10991			}
10992			m.ReadyReplicas = 0
10993			for shift := uint(0); ; shift += 7 {
10994				if shift >= 64 {
10995					return ErrIntOverflowGenerated
10996				}
10997				if iNdEx >= l {
10998					return io.ErrUnexpectedEOF
10999				}
11000				b := dAtA[iNdEx]
11001				iNdEx++
11002				m.ReadyReplicas |= (int32(b) & 0x7F) << shift
11003				if b < 0x80 {
11004					break
11005				}
11006			}
11007		case 5:
11008			if wireType != 0 {
11009				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
11010			}
11011			m.AvailableReplicas = 0
11012			for shift := uint(0); ; shift += 7 {
11013				if shift >= 64 {
11014					return ErrIntOverflowGenerated
11015				}
11016				if iNdEx >= l {
11017					return io.ErrUnexpectedEOF
11018				}
11019				b := dAtA[iNdEx]
11020				iNdEx++
11021				m.AvailableReplicas |= (int32(b) & 0x7F) << shift
11022				if b < 0x80 {
11023					break
11024				}
11025			}
11026		case 6:
11027			if wireType != 2 {
11028				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
11029			}
11030			var msglen int
11031			for shift := uint(0); ; shift += 7 {
11032				if shift >= 64 {
11033					return ErrIntOverflowGenerated
11034				}
11035				if iNdEx >= l {
11036					return io.ErrUnexpectedEOF
11037				}
11038				b := dAtA[iNdEx]
11039				iNdEx++
11040				msglen |= (int(b) & 0x7F) << shift
11041				if b < 0x80 {
11042					break
11043				}
11044			}
11045			if msglen < 0 {
11046				return ErrInvalidLengthGenerated
11047			}
11048			postIndex := iNdEx + msglen
11049			if postIndex > l {
11050				return io.ErrUnexpectedEOF
11051			}
11052			m.Conditions = append(m.Conditions, ReplicaSetCondition{})
11053			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11054				return err
11055			}
11056			iNdEx = postIndex
11057		default:
11058			iNdEx = preIndex
11059			skippy, err := skipGenerated(dAtA[iNdEx:])
11060			if err != nil {
11061				return err
11062			}
11063			if skippy < 0 {
11064				return ErrInvalidLengthGenerated
11065			}
11066			if (iNdEx + skippy) > l {
11067				return io.ErrUnexpectedEOF
11068			}
11069			iNdEx += skippy
11070		}
11071	}
11072
11073	if iNdEx > l {
11074		return io.ErrUnexpectedEOF
11075	}
11076	return nil
11077}
11078func (m *ReplicationControllerDummy) Unmarshal(dAtA []byte) error {
11079	l := len(dAtA)
11080	iNdEx := 0
11081	for iNdEx < l {
11082		preIndex := iNdEx
11083		var wire uint64
11084		for shift := uint(0); ; shift += 7 {
11085			if shift >= 64 {
11086				return ErrIntOverflowGenerated
11087			}
11088			if iNdEx >= l {
11089				return io.ErrUnexpectedEOF
11090			}
11091			b := dAtA[iNdEx]
11092			iNdEx++
11093			wire |= (uint64(b) & 0x7F) << shift
11094			if b < 0x80 {
11095				break
11096			}
11097		}
11098		fieldNum := int32(wire >> 3)
11099		wireType := int(wire & 0x7)
11100		if wireType == 4 {
11101			return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group")
11102		}
11103		if fieldNum <= 0 {
11104			return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire)
11105		}
11106		switch fieldNum {
11107		default:
11108			iNdEx = preIndex
11109			skippy, err := skipGenerated(dAtA[iNdEx:])
11110			if err != nil {
11111				return err
11112			}
11113			if skippy < 0 {
11114				return ErrInvalidLengthGenerated
11115			}
11116			if (iNdEx + skippy) > l {
11117				return io.ErrUnexpectedEOF
11118			}
11119			iNdEx += skippy
11120		}
11121	}
11122
11123	if iNdEx > l {
11124		return io.ErrUnexpectedEOF
11125	}
11126	return nil
11127}
11128func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
11129	l := len(dAtA)
11130	iNdEx := 0
11131	for iNdEx < l {
11132		preIndex := iNdEx
11133		var wire uint64
11134		for shift := uint(0); ; shift += 7 {
11135			if shift >= 64 {
11136				return ErrIntOverflowGenerated
11137			}
11138			if iNdEx >= l {
11139				return io.ErrUnexpectedEOF
11140			}
11141			b := dAtA[iNdEx]
11142			iNdEx++
11143			wire |= (uint64(b) & 0x7F) << shift
11144			if b < 0x80 {
11145				break
11146			}
11147		}
11148		fieldNum := int32(wire >> 3)
11149		wireType := int(wire & 0x7)
11150		if wireType == 4 {
11151			return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
11152		}
11153		if fieldNum <= 0 {
11154			return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
11155		}
11156		switch fieldNum {
11157		case 1:
11158			if wireType != 0 {
11159				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
11160			}
11161			m.Revision = 0
11162			for shift := uint(0); ; shift += 7 {
11163				if shift >= 64 {
11164					return ErrIntOverflowGenerated
11165				}
11166				if iNdEx >= l {
11167					return io.ErrUnexpectedEOF
11168				}
11169				b := dAtA[iNdEx]
11170				iNdEx++
11171				m.Revision |= (int64(b) & 0x7F) << shift
11172				if b < 0x80 {
11173					break
11174				}
11175			}
11176		default:
11177			iNdEx = preIndex
11178			skippy, err := skipGenerated(dAtA[iNdEx:])
11179			if err != nil {
11180				return err
11181			}
11182			if skippy < 0 {
11183				return ErrInvalidLengthGenerated
11184			}
11185			if (iNdEx + skippy) > l {
11186				return io.ErrUnexpectedEOF
11187			}
11188			iNdEx += skippy
11189		}
11190	}
11191
11192	if iNdEx > l {
11193		return io.ErrUnexpectedEOF
11194	}
11195	return nil
11196}
11197func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
11198	l := len(dAtA)
11199	iNdEx := 0
11200	for iNdEx < l {
11201		preIndex := iNdEx
11202		var wire uint64
11203		for shift := uint(0); ; shift += 7 {
11204			if shift >= 64 {
11205				return ErrIntOverflowGenerated
11206			}
11207			if iNdEx >= l {
11208				return io.ErrUnexpectedEOF
11209			}
11210			b := dAtA[iNdEx]
11211			iNdEx++
11212			wire |= (uint64(b) & 0x7F) << shift
11213			if b < 0x80 {
11214				break
11215			}
11216		}
11217		fieldNum := int32(wire >> 3)
11218		wireType := int(wire & 0x7)
11219		if wireType == 4 {
11220			return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
11221		}
11222		if fieldNum <= 0 {
11223			return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
11224		}
11225		switch fieldNum {
11226		case 1:
11227			if wireType != 2 {
11228				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
11229			}
11230			var msglen int
11231			for shift := uint(0); ; shift += 7 {
11232				if shift >= 64 {
11233					return ErrIntOverflowGenerated
11234				}
11235				if iNdEx >= l {
11236					return io.ErrUnexpectedEOF
11237				}
11238				b := dAtA[iNdEx]
11239				iNdEx++
11240				msglen |= (int(b) & 0x7F) << shift
11241				if b < 0x80 {
11242					break
11243				}
11244			}
11245			if msglen < 0 {
11246				return ErrInvalidLengthGenerated
11247			}
11248			postIndex := iNdEx + msglen
11249			if postIndex > l {
11250				return io.ErrUnexpectedEOF
11251			}
11252			if m.MaxUnavailable == nil {
11253				m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11254			}
11255			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11256				return err
11257			}
11258			iNdEx = postIndex
11259		default:
11260			iNdEx = preIndex
11261			skippy, err := skipGenerated(dAtA[iNdEx:])
11262			if err != nil {
11263				return err
11264			}
11265			if skippy < 0 {
11266				return ErrInvalidLengthGenerated
11267			}
11268			if (iNdEx + skippy) > l {
11269				return io.ErrUnexpectedEOF
11270			}
11271			iNdEx += skippy
11272		}
11273	}
11274
11275	if iNdEx > l {
11276		return io.ErrUnexpectedEOF
11277	}
11278	return nil
11279}
11280func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
11281	l := len(dAtA)
11282	iNdEx := 0
11283	for iNdEx < l {
11284		preIndex := iNdEx
11285		var wire uint64
11286		for shift := uint(0); ; shift += 7 {
11287			if shift >= 64 {
11288				return ErrIntOverflowGenerated
11289			}
11290			if iNdEx >= l {
11291				return io.ErrUnexpectedEOF
11292			}
11293			b := dAtA[iNdEx]
11294			iNdEx++
11295			wire |= (uint64(b) & 0x7F) << shift
11296			if b < 0x80 {
11297				break
11298			}
11299		}
11300		fieldNum := int32(wire >> 3)
11301		wireType := int(wire & 0x7)
11302		if wireType == 4 {
11303			return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
11304		}
11305		if fieldNum <= 0 {
11306			return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
11307		}
11308		switch fieldNum {
11309		case 1:
11310			if wireType != 2 {
11311				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
11312			}
11313			var msglen int
11314			for shift := uint(0); ; shift += 7 {
11315				if shift >= 64 {
11316					return ErrIntOverflowGenerated
11317				}
11318				if iNdEx >= l {
11319					return io.ErrUnexpectedEOF
11320				}
11321				b := dAtA[iNdEx]
11322				iNdEx++
11323				msglen |= (int(b) & 0x7F) << shift
11324				if b < 0x80 {
11325					break
11326				}
11327			}
11328			if msglen < 0 {
11329				return ErrInvalidLengthGenerated
11330			}
11331			postIndex := iNdEx + msglen
11332			if postIndex > l {
11333				return io.ErrUnexpectedEOF
11334			}
11335			if m.MaxUnavailable == nil {
11336				m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11337			}
11338			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11339				return err
11340			}
11341			iNdEx = postIndex
11342		case 2:
11343			if wireType != 2 {
11344				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
11345			}
11346			var msglen int
11347			for shift := uint(0); ; shift += 7 {
11348				if shift >= 64 {
11349					return ErrIntOverflowGenerated
11350				}
11351				if iNdEx >= l {
11352					return io.ErrUnexpectedEOF
11353				}
11354				b := dAtA[iNdEx]
11355				iNdEx++
11356				msglen |= (int(b) & 0x7F) << shift
11357				if b < 0x80 {
11358					break
11359				}
11360			}
11361			if msglen < 0 {
11362				return ErrInvalidLengthGenerated
11363			}
11364			postIndex := iNdEx + msglen
11365			if postIndex > l {
11366				return io.ErrUnexpectedEOF
11367			}
11368			if m.MaxSurge == nil {
11369				m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11370			}
11371			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11372				return err
11373			}
11374			iNdEx = postIndex
11375		default:
11376			iNdEx = preIndex
11377			skippy, err := skipGenerated(dAtA[iNdEx:])
11378			if err != nil {
11379				return err
11380			}
11381			if skippy < 0 {
11382				return ErrInvalidLengthGenerated
11383			}
11384			if (iNdEx + skippy) > l {
11385				return io.ErrUnexpectedEOF
11386			}
11387			iNdEx += skippy
11388		}
11389	}
11390
11391	if iNdEx > l {
11392		return io.ErrUnexpectedEOF
11393	}
11394	return nil
11395}
11396func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error {
11397	l := len(dAtA)
11398	iNdEx := 0
11399	for iNdEx < l {
11400		preIndex := iNdEx
11401		var wire uint64
11402		for shift := uint(0); ; shift += 7 {
11403			if shift >= 64 {
11404				return ErrIntOverflowGenerated
11405			}
11406			if iNdEx >= l {
11407				return io.ErrUnexpectedEOF
11408			}
11409			b := dAtA[iNdEx]
11410			iNdEx++
11411			wire |= (uint64(b) & 0x7F) << shift
11412			if b < 0x80 {
11413				break
11414			}
11415		}
11416		fieldNum := int32(wire >> 3)
11417		wireType := int(wire & 0x7)
11418		if wireType == 4 {
11419			return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group")
11420		}
11421		if fieldNum <= 0 {
11422			return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11423		}
11424		switch fieldNum {
11425		case 1:
11426			if wireType != 2 {
11427				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11428			}
11429			var stringLen uint64
11430			for shift := uint(0); ; shift += 7 {
11431				if shift >= 64 {
11432					return ErrIntOverflowGenerated
11433				}
11434				if iNdEx >= l {
11435					return io.ErrUnexpectedEOF
11436				}
11437				b := dAtA[iNdEx]
11438				iNdEx++
11439				stringLen |= (uint64(b) & 0x7F) << shift
11440				if b < 0x80 {
11441					break
11442				}
11443			}
11444			intStringLen := int(stringLen)
11445			if intStringLen < 0 {
11446				return ErrInvalidLengthGenerated
11447			}
11448			postIndex := iNdEx + intStringLen
11449			if postIndex > l {
11450				return io.ErrUnexpectedEOF
11451			}
11452			m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex])
11453			iNdEx = postIndex
11454		case 2:
11455			if wireType != 2 {
11456				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11457			}
11458			var msglen int
11459			for shift := uint(0); ; shift += 7 {
11460				if shift >= 64 {
11461					return ErrIntOverflowGenerated
11462				}
11463				if iNdEx >= l {
11464					return io.ErrUnexpectedEOF
11465				}
11466				b := dAtA[iNdEx]
11467				iNdEx++
11468				msglen |= (int(b) & 0x7F) << shift
11469				if b < 0x80 {
11470					break
11471				}
11472			}
11473			if msglen < 0 {
11474				return ErrInvalidLengthGenerated
11475			}
11476			postIndex := iNdEx + msglen
11477			if postIndex > l {
11478				return io.ErrUnexpectedEOF
11479			}
11480			m.Ranges = append(m.Ranges, IDRange{})
11481			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11482				return err
11483			}
11484			iNdEx = postIndex
11485		default:
11486			iNdEx = preIndex
11487			skippy, err := skipGenerated(dAtA[iNdEx:])
11488			if err != nil {
11489				return err
11490			}
11491			if skippy < 0 {
11492				return ErrInvalidLengthGenerated
11493			}
11494			if (iNdEx + skippy) > l {
11495				return io.ErrUnexpectedEOF
11496			}
11497			iNdEx += skippy
11498		}
11499	}
11500
11501	if iNdEx > l {
11502		return io.ErrUnexpectedEOF
11503	}
11504	return nil
11505}
11506func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error {
11507	l := len(dAtA)
11508	iNdEx := 0
11509	for iNdEx < l {
11510		preIndex := iNdEx
11511		var wire uint64
11512		for shift := uint(0); ; shift += 7 {
11513			if shift >= 64 {
11514				return ErrIntOverflowGenerated
11515			}
11516			if iNdEx >= l {
11517				return io.ErrUnexpectedEOF
11518			}
11519			b := dAtA[iNdEx]
11520			iNdEx++
11521			wire |= (uint64(b) & 0x7F) << shift
11522			if b < 0x80 {
11523				break
11524			}
11525		}
11526		fieldNum := int32(wire >> 3)
11527		wireType := int(wire & 0x7)
11528		if wireType == 4 {
11529			return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
11530		}
11531		if fieldNum <= 0 {
11532			return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11533		}
11534		switch fieldNum {
11535		case 1:
11536			if wireType != 2 {
11537				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11538			}
11539			var stringLen uint64
11540			for shift := uint(0); ; shift += 7 {
11541				if shift >= 64 {
11542					return ErrIntOverflowGenerated
11543				}
11544				if iNdEx >= l {
11545					return io.ErrUnexpectedEOF
11546				}
11547				b := dAtA[iNdEx]
11548				iNdEx++
11549				stringLen |= (uint64(b) & 0x7F) << shift
11550				if b < 0x80 {
11551					break
11552				}
11553			}
11554			intStringLen := int(stringLen)
11555			if intStringLen < 0 {
11556				return ErrInvalidLengthGenerated
11557			}
11558			postIndex := iNdEx + intStringLen
11559			if postIndex > l {
11560				return io.ErrUnexpectedEOF
11561			}
11562			m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex])
11563			iNdEx = postIndex
11564		case 2:
11565			if wireType != 2 {
11566				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11567			}
11568			var msglen int
11569			for shift := uint(0); ; shift += 7 {
11570				if shift >= 64 {
11571					return ErrIntOverflowGenerated
11572				}
11573				if iNdEx >= l {
11574					return io.ErrUnexpectedEOF
11575				}
11576				b := dAtA[iNdEx]
11577				iNdEx++
11578				msglen |= (int(b) & 0x7F) << shift
11579				if b < 0x80 {
11580					break
11581				}
11582			}
11583			if msglen < 0 {
11584				return ErrInvalidLengthGenerated
11585			}
11586			postIndex := iNdEx + msglen
11587			if postIndex > l {
11588				return io.ErrUnexpectedEOF
11589			}
11590			m.Ranges = append(m.Ranges, IDRange{})
11591			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11592				return err
11593			}
11594			iNdEx = postIndex
11595		default:
11596			iNdEx = preIndex
11597			skippy, err := skipGenerated(dAtA[iNdEx:])
11598			if err != nil {
11599				return err
11600			}
11601			if skippy < 0 {
11602				return ErrInvalidLengthGenerated
11603			}
11604			if (iNdEx + skippy) > l {
11605				return io.ErrUnexpectedEOF
11606			}
11607			iNdEx += skippy
11608		}
11609	}
11610
11611	if iNdEx > l {
11612		return io.ErrUnexpectedEOF
11613	}
11614	return nil
11615}
11616func (m *RuntimeClassStrategyOptions) Unmarshal(dAtA []byte) error {
11617	l := len(dAtA)
11618	iNdEx := 0
11619	for iNdEx < l {
11620		preIndex := iNdEx
11621		var wire uint64
11622		for shift := uint(0); ; shift += 7 {
11623			if shift >= 64 {
11624				return ErrIntOverflowGenerated
11625			}
11626			if iNdEx >= l {
11627				return io.ErrUnexpectedEOF
11628			}
11629			b := dAtA[iNdEx]
11630			iNdEx++
11631			wire |= (uint64(b) & 0x7F) << shift
11632			if b < 0x80 {
11633				break
11634			}
11635		}
11636		fieldNum := int32(wire >> 3)
11637		wireType := int(wire & 0x7)
11638		if wireType == 4 {
11639			return fmt.Errorf("proto: RuntimeClassStrategyOptions: wiretype end group for non-group")
11640		}
11641		if fieldNum <= 0 {
11642			return fmt.Errorf("proto: RuntimeClassStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11643		}
11644		switch fieldNum {
11645		case 1:
11646			if wireType != 2 {
11647				return fmt.Errorf("proto: wrong wireType = %d for field AllowedRuntimeClassNames", wireType)
11648			}
11649			var stringLen uint64
11650			for shift := uint(0); ; shift += 7 {
11651				if shift >= 64 {
11652					return ErrIntOverflowGenerated
11653				}
11654				if iNdEx >= l {
11655					return io.ErrUnexpectedEOF
11656				}
11657				b := dAtA[iNdEx]
11658				iNdEx++
11659				stringLen |= (uint64(b) & 0x7F) << shift
11660				if b < 0x80 {
11661					break
11662				}
11663			}
11664			intStringLen := int(stringLen)
11665			if intStringLen < 0 {
11666				return ErrInvalidLengthGenerated
11667			}
11668			postIndex := iNdEx + intStringLen
11669			if postIndex > l {
11670				return io.ErrUnexpectedEOF
11671			}
11672			m.AllowedRuntimeClassNames = append(m.AllowedRuntimeClassNames, string(dAtA[iNdEx:postIndex]))
11673			iNdEx = postIndex
11674		case 2:
11675			if wireType != 2 {
11676				return fmt.Errorf("proto: wrong wireType = %d for field DefaultRuntimeClassName", wireType)
11677			}
11678			var stringLen uint64
11679			for shift := uint(0); ; shift += 7 {
11680				if shift >= 64 {
11681					return ErrIntOverflowGenerated
11682				}
11683				if iNdEx >= l {
11684					return io.ErrUnexpectedEOF
11685				}
11686				b := dAtA[iNdEx]
11687				iNdEx++
11688				stringLen |= (uint64(b) & 0x7F) << shift
11689				if b < 0x80 {
11690					break
11691				}
11692			}
11693			intStringLen := int(stringLen)
11694			if intStringLen < 0 {
11695				return ErrInvalidLengthGenerated
11696			}
11697			postIndex := iNdEx + intStringLen
11698			if postIndex > l {
11699				return io.ErrUnexpectedEOF
11700			}
11701			s := string(dAtA[iNdEx:postIndex])
11702			m.DefaultRuntimeClassName = &s
11703			iNdEx = postIndex
11704		default:
11705			iNdEx = preIndex
11706			skippy, err := skipGenerated(dAtA[iNdEx:])
11707			if err != nil {
11708				return err
11709			}
11710			if skippy < 0 {
11711				return ErrInvalidLengthGenerated
11712			}
11713			if (iNdEx + skippy) > l {
11714				return io.ErrUnexpectedEOF
11715			}
11716			iNdEx += skippy
11717		}
11718	}
11719
11720	if iNdEx > l {
11721		return io.ErrUnexpectedEOF
11722	}
11723	return nil
11724}
11725func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error {
11726	l := len(dAtA)
11727	iNdEx := 0
11728	for iNdEx < l {
11729		preIndex := iNdEx
11730		var wire uint64
11731		for shift := uint(0); ; shift += 7 {
11732			if shift >= 64 {
11733				return ErrIntOverflowGenerated
11734			}
11735			if iNdEx >= l {
11736				return io.ErrUnexpectedEOF
11737			}
11738			b := dAtA[iNdEx]
11739			iNdEx++
11740			wire |= (uint64(b) & 0x7F) << shift
11741			if b < 0x80 {
11742				break
11743			}
11744		}
11745		fieldNum := int32(wire >> 3)
11746		wireType := int(wire & 0x7)
11747		if wireType == 4 {
11748			return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group")
11749		}
11750		if fieldNum <= 0 {
11751			return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11752		}
11753		switch fieldNum {
11754		case 1:
11755			if wireType != 2 {
11756				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11757			}
11758			var stringLen uint64
11759			for shift := uint(0); ; shift += 7 {
11760				if shift >= 64 {
11761					return ErrIntOverflowGenerated
11762				}
11763				if iNdEx >= l {
11764					return io.ErrUnexpectedEOF
11765				}
11766				b := dAtA[iNdEx]
11767				iNdEx++
11768				stringLen |= (uint64(b) & 0x7F) << shift
11769				if b < 0x80 {
11770					break
11771				}
11772			}
11773			intStringLen := int(stringLen)
11774			if intStringLen < 0 {
11775				return ErrInvalidLengthGenerated
11776			}
11777			postIndex := iNdEx + intStringLen
11778			if postIndex > l {
11779				return io.ErrUnexpectedEOF
11780			}
11781			m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex])
11782			iNdEx = postIndex
11783		case 2:
11784			if wireType != 2 {
11785				return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
11786			}
11787			var msglen int
11788			for shift := uint(0); ; shift += 7 {
11789				if shift >= 64 {
11790					return ErrIntOverflowGenerated
11791				}
11792				if iNdEx >= l {
11793					return io.ErrUnexpectedEOF
11794				}
11795				b := dAtA[iNdEx]
11796				iNdEx++
11797				msglen |= (int(b) & 0x7F) << shift
11798				if b < 0x80 {
11799					break
11800				}
11801			}
11802			if msglen < 0 {
11803				return ErrInvalidLengthGenerated
11804			}
11805			postIndex := iNdEx + msglen
11806			if postIndex > l {
11807				return io.ErrUnexpectedEOF
11808			}
11809			if m.SELinuxOptions == nil {
11810				m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{}
11811			}
11812			if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11813				return err
11814			}
11815			iNdEx = postIndex
11816		default:
11817			iNdEx = preIndex
11818			skippy, err := skipGenerated(dAtA[iNdEx:])
11819			if err != nil {
11820				return err
11821			}
11822			if skippy < 0 {
11823				return ErrInvalidLengthGenerated
11824			}
11825			if (iNdEx + skippy) > l {
11826				return io.ErrUnexpectedEOF
11827			}
11828			iNdEx += skippy
11829		}
11830	}
11831
11832	if iNdEx > l {
11833		return io.ErrUnexpectedEOF
11834	}
11835	return nil
11836}
11837func (m *Scale) Unmarshal(dAtA []byte) error {
11838	l := len(dAtA)
11839	iNdEx := 0
11840	for iNdEx < l {
11841		preIndex := iNdEx
11842		var wire uint64
11843		for shift := uint(0); ; shift += 7 {
11844			if shift >= 64 {
11845				return ErrIntOverflowGenerated
11846			}
11847			if iNdEx >= l {
11848				return io.ErrUnexpectedEOF
11849			}
11850			b := dAtA[iNdEx]
11851			iNdEx++
11852			wire |= (uint64(b) & 0x7F) << shift
11853			if b < 0x80 {
11854				break
11855			}
11856		}
11857		fieldNum := int32(wire >> 3)
11858		wireType := int(wire & 0x7)
11859		if wireType == 4 {
11860			return fmt.Errorf("proto: Scale: wiretype end group for non-group")
11861		}
11862		if fieldNum <= 0 {
11863			return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
11864		}
11865		switch fieldNum {
11866		case 1:
11867			if wireType != 2 {
11868				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
11869			}
11870			var msglen int
11871			for shift := uint(0); ; shift += 7 {
11872				if shift >= 64 {
11873					return ErrIntOverflowGenerated
11874				}
11875				if iNdEx >= l {
11876					return io.ErrUnexpectedEOF
11877				}
11878				b := dAtA[iNdEx]
11879				iNdEx++
11880				msglen |= (int(b) & 0x7F) << shift
11881				if b < 0x80 {
11882					break
11883				}
11884			}
11885			if msglen < 0 {
11886				return ErrInvalidLengthGenerated
11887			}
11888			postIndex := iNdEx + msglen
11889			if postIndex > l {
11890				return io.ErrUnexpectedEOF
11891			}
11892			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11893				return err
11894			}
11895			iNdEx = postIndex
11896		case 2:
11897			if wireType != 2 {
11898				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
11899			}
11900			var msglen int
11901			for shift := uint(0); ; shift += 7 {
11902				if shift >= 64 {
11903					return ErrIntOverflowGenerated
11904				}
11905				if iNdEx >= l {
11906					return io.ErrUnexpectedEOF
11907				}
11908				b := dAtA[iNdEx]
11909				iNdEx++
11910				msglen |= (int(b) & 0x7F) << shift
11911				if b < 0x80 {
11912					break
11913				}
11914			}
11915			if msglen < 0 {
11916				return ErrInvalidLengthGenerated
11917			}
11918			postIndex := iNdEx + msglen
11919			if postIndex > l {
11920				return io.ErrUnexpectedEOF
11921			}
11922			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11923				return err
11924			}
11925			iNdEx = postIndex
11926		case 3:
11927			if wireType != 2 {
11928				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
11929			}
11930			var msglen int
11931			for shift := uint(0); ; shift += 7 {
11932				if shift >= 64 {
11933					return ErrIntOverflowGenerated
11934				}
11935				if iNdEx >= l {
11936					return io.ErrUnexpectedEOF
11937				}
11938				b := dAtA[iNdEx]
11939				iNdEx++
11940				msglen |= (int(b) & 0x7F) << shift
11941				if b < 0x80 {
11942					break
11943				}
11944			}
11945			if msglen < 0 {
11946				return ErrInvalidLengthGenerated
11947			}
11948			postIndex := iNdEx + msglen
11949			if postIndex > l {
11950				return io.ErrUnexpectedEOF
11951			}
11952			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11953				return err
11954			}
11955			iNdEx = postIndex
11956		default:
11957			iNdEx = preIndex
11958			skippy, err := skipGenerated(dAtA[iNdEx:])
11959			if err != nil {
11960				return err
11961			}
11962			if skippy < 0 {
11963				return ErrInvalidLengthGenerated
11964			}
11965			if (iNdEx + skippy) > l {
11966				return io.ErrUnexpectedEOF
11967			}
11968			iNdEx += skippy
11969		}
11970	}
11971
11972	if iNdEx > l {
11973		return io.ErrUnexpectedEOF
11974	}
11975	return nil
11976}
11977func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
11978	l := len(dAtA)
11979	iNdEx := 0
11980	for iNdEx < l {
11981		preIndex := iNdEx
11982		var wire uint64
11983		for shift := uint(0); ; shift += 7 {
11984			if shift >= 64 {
11985				return ErrIntOverflowGenerated
11986			}
11987			if iNdEx >= l {
11988				return io.ErrUnexpectedEOF
11989			}
11990			b := dAtA[iNdEx]
11991			iNdEx++
11992			wire |= (uint64(b) & 0x7F) << shift
11993			if b < 0x80 {
11994				break
11995			}
11996		}
11997		fieldNum := int32(wire >> 3)
11998		wireType := int(wire & 0x7)
11999		if wireType == 4 {
12000			return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
12001		}
12002		if fieldNum <= 0 {
12003			return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
12004		}
12005		switch fieldNum {
12006		case 1:
12007			if wireType != 0 {
12008				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
12009			}
12010			m.Replicas = 0
12011			for shift := uint(0); ; shift += 7 {
12012				if shift >= 64 {
12013					return ErrIntOverflowGenerated
12014				}
12015				if iNdEx >= l {
12016					return io.ErrUnexpectedEOF
12017				}
12018				b := dAtA[iNdEx]
12019				iNdEx++
12020				m.Replicas |= (int32(b) & 0x7F) << shift
12021				if b < 0x80 {
12022					break
12023				}
12024			}
12025		default:
12026			iNdEx = preIndex
12027			skippy, err := skipGenerated(dAtA[iNdEx:])
12028			if err != nil {
12029				return err
12030			}
12031			if skippy < 0 {
12032				return ErrInvalidLengthGenerated
12033			}
12034			if (iNdEx + skippy) > l {
12035				return io.ErrUnexpectedEOF
12036			}
12037			iNdEx += skippy
12038		}
12039	}
12040
12041	if iNdEx > l {
12042		return io.ErrUnexpectedEOF
12043	}
12044	return nil
12045}
12046func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
12047	l := len(dAtA)
12048	iNdEx := 0
12049	for iNdEx < l {
12050		preIndex := iNdEx
12051		var wire uint64
12052		for shift := uint(0); ; shift += 7 {
12053			if shift >= 64 {
12054				return ErrIntOverflowGenerated
12055			}
12056			if iNdEx >= l {
12057				return io.ErrUnexpectedEOF
12058			}
12059			b := dAtA[iNdEx]
12060			iNdEx++
12061			wire |= (uint64(b) & 0x7F) << shift
12062			if b < 0x80 {
12063				break
12064			}
12065		}
12066		fieldNum := int32(wire >> 3)
12067		wireType := int(wire & 0x7)
12068		if wireType == 4 {
12069			return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
12070		}
12071		if fieldNum <= 0 {
12072			return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
12073		}
12074		switch fieldNum {
12075		case 1:
12076			if wireType != 0 {
12077				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
12078			}
12079			m.Replicas = 0
12080			for shift := uint(0); ; shift += 7 {
12081				if shift >= 64 {
12082					return ErrIntOverflowGenerated
12083				}
12084				if iNdEx >= l {
12085					return io.ErrUnexpectedEOF
12086				}
12087				b := dAtA[iNdEx]
12088				iNdEx++
12089				m.Replicas |= (int32(b) & 0x7F) << shift
12090				if b < 0x80 {
12091					break
12092				}
12093			}
12094		case 2:
12095			if wireType != 2 {
12096				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
12097			}
12098			var msglen int
12099			for shift := uint(0); ; shift += 7 {
12100				if shift >= 64 {
12101					return ErrIntOverflowGenerated
12102				}
12103				if iNdEx >= l {
12104					return io.ErrUnexpectedEOF
12105				}
12106				b := dAtA[iNdEx]
12107				iNdEx++
12108				msglen |= (int(b) & 0x7F) << shift
12109				if b < 0x80 {
12110					break
12111				}
12112			}
12113			if msglen < 0 {
12114				return ErrInvalidLengthGenerated
12115			}
12116			postIndex := iNdEx + msglen
12117			if postIndex > l {
12118				return io.ErrUnexpectedEOF
12119			}
12120			if m.Selector == nil {
12121				m.Selector = make(map[string]string)
12122			}
12123			var mapkey string
12124			var mapvalue string
12125			for iNdEx < postIndex {
12126				entryPreIndex := iNdEx
12127				var wire uint64
12128				for shift := uint(0); ; shift += 7 {
12129					if shift >= 64 {
12130						return ErrIntOverflowGenerated
12131					}
12132					if iNdEx >= l {
12133						return io.ErrUnexpectedEOF
12134					}
12135					b := dAtA[iNdEx]
12136					iNdEx++
12137					wire |= (uint64(b) & 0x7F) << shift
12138					if b < 0x80 {
12139						break
12140					}
12141				}
12142				fieldNum := int32(wire >> 3)
12143				if fieldNum == 1 {
12144					var stringLenmapkey uint64
12145					for shift := uint(0); ; shift += 7 {
12146						if shift >= 64 {
12147							return ErrIntOverflowGenerated
12148						}
12149						if iNdEx >= l {
12150							return io.ErrUnexpectedEOF
12151						}
12152						b := dAtA[iNdEx]
12153						iNdEx++
12154						stringLenmapkey |= (uint64(b) & 0x7F) << shift
12155						if b < 0x80 {
12156							break
12157						}
12158					}
12159					intStringLenmapkey := int(stringLenmapkey)
12160					if intStringLenmapkey < 0 {
12161						return ErrInvalidLengthGenerated
12162					}
12163					postStringIndexmapkey := iNdEx + intStringLenmapkey
12164					if postStringIndexmapkey > l {
12165						return io.ErrUnexpectedEOF
12166					}
12167					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
12168					iNdEx = postStringIndexmapkey
12169				} else if fieldNum == 2 {
12170					var stringLenmapvalue uint64
12171					for shift := uint(0); ; shift += 7 {
12172						if shift >= 64 {
12173							return ErrIntOverflowGenerated
12174						}
12175						if iNdEx >= l {
12176							return io.ErrUnexpectedEOF
12177						}
12178						b := dAtA[iNdEx]
12179						iNdEx++
12180						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
12181						if b < 0x80 {
12182							break
12183						}
12184					}
12185					intStringLenmapvalue := int(stringLenmapvalue)
12186					if intStringLenmapvalue < 0 {
12187						return ErrInvalidLengthGenerated
12188					}
12189					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
12190					if postStringIndexmapvalue > l {
12191						return io.ErrUnexpectedEOF
12192					}
12193					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
12194					iNdEx = postStringIndexmapvalue
12195				} else {
12196					iNdEx = entryPreIndex
12197					skippy, err := skipGenerated(dAtA[iNdEx:])
12198					if err != nil {
12199						return err
12200					}
12201					if skippy < 0 {
12202						return ErrInvalidLengthGenerated
12203					}
12204					if (iNdEx + skippy) > postIndex {
12205						return io.ErrUnexpectedEOF
12206					}
12207					iNdEx += skippy
12208				}
12209			}
12210			m.Selector[mapkey] = mapvalue
12211			iNdEx = postIndex
12212		case 3:
12213			if wireType != 2 {
12214				return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
12215			}
12216			var stringLen uint64
12217			for shift := uint(0); ; shift += 7 {
12218				if shift >= 64 {
12219					return ErrIntOverflowGenerated
12220				}
12221				if iNdEx >= l {
12222					return io.ErrUnexpectedEOF
12223				}
12224				b := dAtA[iNdEx]
12225				iNdEx++
12226				stringLen |= (uint64(b) & 0x7F) << shift
12227				if b < 0x80 {
12228					break
12229				}
12230			}
12231			intStringLen := int(stringLen)
12232			if intStringLen < 0 {
12233				return ErrInvalidLengthGenerated
12234			}
12235			postIndex := iNdEx + intStringLen
12236			if postIndex > l {
12237				return io.ErrUnexpectedEOF
12238			}
12239			m.TargetSelector = string(dAtA[iNdEx:postIndex])
12240			iNdEx = postIndex
12241		default:
12242			iNdEx = preIndex
12243			skippy, err := skipGenerated(dAtA[iNdEx:])
12244			if err != nil {
12245				return err
12246			}
12247			if skippy < 0 {
12248				return ErrInvalidLengthGenerated
12249			}
12250			if (iNdEx + skippy) > l {
12251				return io.ErrUnexpectedEOF
12252			}
12253			iNdEx += skippy
12254		}
12255	}
12256
12257	if iNdEx > l {
12258		return io.ErrUnexpectedEOF
12259	}
12260	return nil
12261}
12262func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error {
12263	l := len(dAtA)
12264	iNdEx := 0
12265	for iNdEx < l {
12266		preIndex := iNdEx
12267		var wire uint64
12268		for shift := uint(0); ; shift += 7 {
12269			if shift >= 64 {
12270				return ErrIntOverflowGenerated
12271			}
12272			if iNdEx >= l {
12273				return io.ErrUnexpectedEOF
12274			}
12275			b := dAtA[iNdEx]
12276			iNdEx++
12277			wire |= (uint64(b) & 0x7F) << shift
12278			if b < 0x80 {
12279				break
12280			}
12281		}
12282		fieldNum := int32(wire >> 3)
12283		wireType := int(wire & 0x7)
12284		if wireType == 4 {
12285			return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
12286		}
12287		if fieldNum <= 0 {
12288			return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
12289		}
12290		switch fieldNum {
12291		case 1:
12292			if wireType != 2 {
12293				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
12294			}
12295			var stringLen uint64
12296			for shift := uint(0); ; shift += 7 {
12297				if shift >= 64 {
12298					return ErrIntOverflowGenerated
12299				}
12300				if iNdEx >= l {
12301					return io.ErrUnexpectedEOF
12302				}
12303				b := dAtA[iNdEx]
12304				iNdEx++
12305				stringLen |= (uint64(b) & 0x7F) << shift
12306				if b < 0x80 {
12307					break
12308				}
12309			}
12310			intStringLen := int(stringLen)
12311			if intStringLen < 0 {
12312				return ErrInvalidLengthGenerated
12313			}
12314			postIndex := iNdEx + intStringLen
12315			if postIndex > l {
12316				return io.ErrUnexpectedEOF
12317			}
12318			m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex])
12319			iNdEx = postIndex
12320		case 2:
12321			if wireType != 2 {
12322				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
12323			}
12324			var msglen int
12325			for shift := uint(0); ; shift += 7 {
12326				if shift >= 64 {
12327					return ErrIntOverflowGenerated
12328				}
12329				if iNdEx >= l {
12330					return io.ErrUnexpectedEOF
12331				}
12332				b := dAtA[iNdEx]
12333				iNdEx++
12334				msglen |= (int(b) & 0x7F) << shift
12335				if b < 0x80 {
12336					break
12337				}
12338			}
12339			if msglen < 0 {
12340				return ErrInvalidLengthGenerated
12341			}
12342			postIndex := iNdEx + msglen
12343			if postIndex > l {
12344				return io.ErrUnexpectedEOF
12345			}
12346			m.Ranges = append(m.Ranges, IDRange{})
12347			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
12348				return err
12349			}
12350			iNdEx = postIndex
12351		default:
12352			iNdEx = preIndex
12353			skippy, err := skipGenerated(dAtA[iNdEx:])
12354			if err != nil {
12355				return err
12356			}
12357			if skippy < 0 {
12358				return ErrInvalidLengthGenerated
12359			}
12360			if (iNdEx + skippy) > l {
12361				return io.ErrUnexpectedEOF
12362			}
12363			iNdEx += skippy
12364		}
12365	}
12366
12367	if iNdEx > l {
12368		return io.ErrUnexpectedEOF
12369	}
12370	return nil
12371}
12372func skipGenerated(dAtA []byte) (n int, err error) {
12373	l := len(dAtA)
12374	iNdEx := 0
12375	for iNdEx < l {
12376		var wire uint64
12377		for shift := uint(0); ; shift += 7 {
12378			if shift >= 64 {
12379				return 0, ErrIntOverflowGenerated
12380			}
12381			if iNdEx >= l {
12382				return 0, io.ErrUnexpectedEOF
12383			}
12384			b := dAtA[iNdEx]
12385			iNdEx++
12386			wire |= (uint64(b) & 0x7F) << shift
12387			if b < 0x80 {
12388				break
12389			}
12390		}
12391		wireType := int(wire & 0x7)
12392		switch wireType {
12393		case 0:
12394			for shift := uint(0); ; shift += 7 {
12395				if shift >= 64 {
12396					return 0, ErrIntOverflowGenerated
12397				}
12398				if iNdEx >= l {
12399					return 0, io.ErrUnexpectedEOF
12400				}
12401				iNdEx++
12402				if dAtA[iNdEx-1] < 0x80 {
12403					break
12404				}
12405			}
12406			return iNdEx, nil
12407		case 1:
12408			iNdEx += 8
12409			return iNdEx, nil
12410		case 2:
12411			var length int
12412			for shift := uint(0); ; shift += 7 {
12413				if shift >= 64 {
12414					return 0, ErrIntOverflowGenerated
12415				}
12416				if iNdEx >= l {
12417					return 0, io.ErrUnexpectedEOF
12418				}
12419				b := dAtA[iNdEx]
12420				iNdEx++
12421				length |= (int(b) & 0x7F) << shift
12422				if b < 0x80 {
12423					break
12424				}
12425			}
12426			iNdEx += length
12427			if length < 0 {
12428				return 0, ErrInvalidLengthGenerated
12429			}
12430			return iNdEx, nil
12431		case 3:
12432			for {
12433				var innerWire uint64
12434				var start int = iNdEx
12435				for shift := uint(0); ; shift += 7 {
12436					if shift >= 64 {
12437						return 0, ErrIntOverflowGenerated
12438					}
12439					if iNdEx >= l {
12440						return 0, io.ErrUnexpectedEOF
12441					}
12442					b := dAtA[iNdEx]
12443					iNdEx++
12444					innerWire |= (uint64(b) & 0x7F) << shift
12445					if b < 0x80 {
12446						break
12447					}
12448				}
12449				innerWireType := int(innerWire & 0x7)
12450				if innerWireType == 4 {
12451					break
12452				}
12453				next, err := skipGenerated(dAtA[start:])
12454				if err != nil {
12455					return 0, err
12456				}
12457				iNdEx = start + next
12458			}
12459			return iNdEx, nil
12460		case 4:
12461			return iNdEx, nil
12462		case 5:
12463			iNdEx += 4
12464			return iNdEx, nil
12465		default:
12466			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
12467		}
12468	}
12469	panic("unreachable")
12470}
12471
12472var (
12473	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
12474	ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
12475)
12476
12477func init() {
12478	proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptorGenerated)
12479}
12480
12481var fileDescriptorGenerated = []byte{
12482	// 3695 bytes of a gzipped FileDescriptorProto
12483	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x4f, 0x6c, 0x1b, 0x47,
12484	0x77, 0xf7, 0x92, 0x94, 0x48, 0x3d, 0xfd, 0x1f, 0xc9, 0x12, 0x3f, 0x3b, 0x16, 0xfd, 0x6d, 0x00,
12485	0xd7, 0x49, 0x6d, 0x32, 0x76, 0x6c, 0x7f, 0xae, 0x8d, 0x26, 0x11, 0x25, 0xcb, 0x56, 0xaa, 0x3f,
12486	0xcc, 0x50, 0x72, 0x83, 0xa0, 0x49, 0xb3, 0x22, 0x47, 0xd4, 0x5a, 0xcb, 0xdd, 0xcd, 0xce, 0x52,
12487	0x11, 0x81, 0x1e, 0x7a, 0x28, 0x0a, 0x14, 0x68, 0xd1, 0x5e, 0xd2, 0xf6, 0xd8, 0xa0, 0x40, 0x4f,
12488	0x2d, 0xda, 0x5b, 0x7b, 0x08, 0x02, 0x14, 0x48, 0x01, 0xa3, 0x48, 0x8b, 0xdc, 0x9a, 0x93, 0xd0,
12489	0x28, 0xa7, 0xa2, 0xa7, 0xde, 0x0a, 0x1f, 0x8a, 0x62, 0x66, 0x67, 0xff, 0xef, 0x8a, 0x2b, 0xc5,
12490	0x16, 0x8a, 0xe2, 0xbb, 0x89, 0xf3, 0xde, 0xfb, 0xbd, 0x37, 0x33, 0x6f, 0xde, 0x7b, 0x33, 0xfb,
12491	0x04, 0x2b, 0xfb, 0xf7, 0x69, 0x55, 0x35, 0x6a, 0xfb, 0xbd, 0x1d, 0x62, 0xe9, 0xc4, 0x26, 0xb4,
12492	0x76, 0x40, 0xf4, 0xb6, 0x61, 0xd5, 0x04, 0x41, 0x31, 0xd5, 0x1a, 0x39, 0xb4, 0x89, 0x4e, 0x55,
12493	0x43, 0xa7, 0xb5, 0x83, 0x5b, 0x3b, 0xc4, 0x56, 0x6e, 0xd5, 0x3a, 0x44, 0x27, 0x96, 0x62, 0x93,
12494	0x76, 0xd5, 0xb4, 0x0c, 0xdb, 0x40, 0x57, 0x1c, 0xf6, 0xaa, 0x62, 0xaa, 0x55, 0x9f, 0xbd, 0x2a,
12495	0xd8, 0x2f, 0xdd, 0xec, 0xa8, 0xf6, 0x5e, 0x6f, 0xa7, 0xda, 0x32, 0xba, 0xb5, 0x8e, 0xd1, 0x31,
12496	0x6a, 0x5c, 0x6a, 0xa7, 0xb7, 0xcb, 0x7f, 0xf1, 0x1f, 0xfc, 0x2f, 0x07, 0xed, 0x92, 0x1c, 0x50,
12497	0xde, 0x32, 0x2c, 0x52, 0x3b, 0x88, 0x69, 0xbc, 0x74, 0xc7, 0xe7, 0xe9, 0x2a, 0xad, 0x3d, 0x55,
12498	0x27, 0x56, 0xbf, 0x66, 0xee, 0x77, 0xd8, 0x00, 0xad, 0x75, 0x89, 0xad, 0x24, 0x49, 0xd5, 0xd2,
12499	0xa4, 0xac, 0x9e, 0x6e, 0xab, 0x5d, 0x12, 0x13, 0xb8, 0x37, 0x48, 0x80, 0xb6, 0xf6, 0x48, 0x57,
12500	0x89, 0xc9, 0xbd, 0x9d, 0x26, 0xd7, 0xb3, 0x55, 0xad, 0xa6, 0xea, 0x36, 0xb5, 0xad, 0xa8, 0x90,
12501	0x7c, 0x07, 0xa6, 0x16, 0x35, 0xcd, 0xf8, 0x9c, 0xb4, 0x97, 0x9a, 0xab, 0xcb, 0x96, 0x7a, 0x40,
12502	0x2c, 0x74, 0x15, 0x0a, 0xba, 0xd2, 0x25, 0x65, 0xe9, 0xaa, 0x74, 0x7d, 0xa4, 0x3e, 0xf6, 0xfc,
12503	0xa8, 0x72, 0xe1, 0xf8, 0xa8, 0x52, 0xd8, 0x50, 0xba, 0x04, 0x73, 0x8a, 0xfc, 0x10, 0xa6, 0x85,
12504	0xd4, 0x8a, 0x46, 0x0e, 0x9f, 0x1a, 0x5a, 0xaf, 0x4b, 0xd0, 0x35, 0x18, 0x6e, 0x73, 0x00, 0x21,
12505	0x38, 0x21, 0x04, 0x87, 0x1d, 0x58, 0x2c, 0xa8, 0x32, 0x85, 0x49, 0x21, 0xfc, 0xc4, 0xa0, 0x76,
12506	0x43, 0xb1, 0xf7, 0xd0, 0x6d, 0x00, 0x53, 0xb1, 0xf7, 0x1a, 0x16, 0xd9, 0x55, 0x0f, 0x85, 0x38,
12507	0x12, 0xe2, 0xd0, 0xf0, 0x28, 0x38, 0xc0, 0x85, 0x6e, 0x40, 0xc9, 0x22, 0x4a, 0x7b, 0x53, 0xd7,
12508	0xfa, 0xe5, 0xdc, 0x55, 0xe9, 0x7a, 0xa9, 0x3e, 0x25, 0x24, 0x4a, 0x58, 0x8c, 0x63, 0x8f, 0x43,
12509	0xfe, 0x22, 0x07, 0x23, 0xcb, 0x0a, 0xe9, 0x1a, 0x7a, 0x93, 0xd8, 0xe8, 0x53, 0x28, 0xb1, 0xed,
12510	0x6a, 0x2b, 0xb6, 0xc2, 0xb5, 0x8d, 0xde, 0x7e, 0xab, 0xea, 0xbb, 0x93, 0xb7, 0x7a, 0x55, 0x73,
12511	0xbf, 0xc3, 0x06, 0x68, 0x95, 0x71, 0x57, 0x0f, 0x6e, 0x55, 0x37, 0x77, 0x9e, 0x91, 0x96, 0xbd,
12512	0x4e, 0x6c, 0xc5, 0xb7, 0xcf, 0x1f, 0xc3, 0x1e, 0x2a, 0xda, 0x80, 0x02, 0x35, 0x49, 0x8b, 0x5b,
12513	0x36, 0x7a, 0xfb, 0x46, 0xf5, 0x44, 0x67, 0xad, 0x7a, 0x96, 0x35, 0x4d, 0xd2, 0xf2, 0x57, 0x9c,
12514	0xfd, 0xc2, 0x1c, 0x07, 0x3d, 0x85, 0x61, 0x6a, 0x2b, 0x76, 0x8f, 0x96, 0xf3, 0x1c, 0xb1, 0x9a,
12515	0x19, 0x91, 0x4b, 0xf9, 0x9b, 0xe1, 0xfc, 0xc6, 0x02, 0x4d, 0xfe, 0x8f, 0x1c, 0x20, 0x8f, 0x77,
12516	0xc9, 0xd0, 0xdb, 0xaa, 0xad, 0x1a, 0x3a, 0x7a, 0x00, 0x05, 0xbb, 0x6f, 0xba, 0x2e, 0x70, 0xcd,
12517	0x35, 0x68, 0xab, 0x6f, 0x92, 0x17, 0x47, 0x95, 0xb9, 0xb8, 0x04, 0xa3, 0x60, 0x2e, 0x83, 0xd6,
12518	0x3c, 0x53, 0x73, 0x5c, 0xfa, 0x4e, 0x58, 0xf5, 0x8b, 0xa3, 0x4a, 0xc2, 0x61, 0xab, 0x7a, 0x48,
12519	0x61, 0x03, 0xd1, 0x01, 0x20, 0x4d, 0xa1, 0xf6, 0x96, 0xa5, 0xe8, 0xd4, 0xd1, 0xa4, 0x76, 0x89,
12520	0x58, 0x84, 0x37, 0xb3, 0x6d, 0x1a, 0x93, 0xa8, 0x5f, 0x12, 0x56, 0xa0, 0xb5, 0x18, 0x1a, 0x4e,
12521	0xd0, 0xc0, 0xbc, 0xd9, 0x22, 0x0a, 0x35, 0xf4, 0x72, 0x21, 0xec, 0xcd, 0x98, 0x8f, 0x62, 0x41,
12522	0x45, 0x6f, 0x40, 0xb1, 0x4b, 0x28, 0x55, 0x3a, 0xa4, 0x3c, 0xc4, 0x19, 0x27, 0x05, 0x63, 0x71,
12523	0xdd, 0x19, 0xc6, 0x2e, 0x5d, 0xfe, 0x4a, 0x82, 0x71, 0x6f, 0xe5, 0xd6, 0x54, 0x6a, 0xa3, 0xdf,
12524	0x8a, 0xf9, 0x61, 0x35, 0xdb, 0x94, 0x98, 0x34, 0xf7, 0x42, 0xcf, 0xe7, 0xdd, 0x91, 0x80, 0x0f,
12525	0xae, 0xc3, 0x90, 0x6a, 0x93, 0x2e, 0xdb, 0x87, 0xfc, 0xf5, 0xd1, 0xdb, 0xd7, 0xb3, 0xba, 0x4c,
12526	0x7d, 0x5c, 0x80, 0x0e, 0xad, 0x32, 0x71, 0xec, 0xa0, 0xc8, 0x7f, 0x5a, 0x08, 0x98, 0xcf, 0x5c,
12527	0x13, 0x7d, 0x0c, 0x25, 0x4a, 0x34, 0xd2, 0xb2, 0x0d, 0x4b, 0x98, 0xff, 0x76, 0x46, 0xf3, 0x95,
12528	0x1d, 0xa2, 0x35, 0x85, 0x68, 0x7d, 0x8c, 0xd9, 0xef, 0xfe, 0xc2, 0x1e, 0x24, 0xfa, 0x00, 0x4a,
12529	0x36, 0xe9, 0x9a, 0x9a, 0x62, 0x13, 0x71, 0x8e, 0x5e, 0x0f, 0x4e, 0x81, 0x79, 0x0e, 0x03, 0x6b,
12530	0x18, 0xed, 0x2d, 0xc1, 0xc6, 0x8f, 0x8f, 0xb7, 0x24, 0xee, 0x28, 0xf6, 0x60, 0xd0, 0x01, 0x4c,
12531	0xf4, 0xcc, 0x36, 0xe3, 0xb4, 0x59, 0x14, 0xec, 0xf4, 0x85, 0x27, 0xdd, 0xcb, 0xba, 0x36, 0xdb,
12532	0x21, 0xe9, 0xfa, 0x9c, 0xd0, 0x35, 0x11, 0x1e, 0xc7, 0x11, 0x2d, 0x68, 0x11, 0x26, 0xbb, 0xaa,
12533	0xce, 0xe2, 0x52, 0xbf, 0x49, 0x5a, 0x86, 0xde, 0xa6, 0xdc, 0xad, 0x86, 0xea, 0xf3, 0x02, 0x60,
12534	0x72, 0x3d, 0x4c, 0xc6, 0x51, 0x7e, 0xf4, 0x3e, 0x20, 0x77, 0x1a, 0x8f, 0x9d, 0x20, 0xae, 0x1a,
12535	0x3a, 0xf7, 0xb9, 0xbc, 0xef, 0xdc, 0x5b, 0x31, 0x0e, 0x9c, 0x20, 0x85, 0xd6, 0x60, 0xd6, 0x22,
12536	0x07, 0x2a, 0x9b, 0xe3, 0x13, 0x95, 0xda, 0x86, 0xd5, 0x5f, 0x53, 0xbb, 0xaa, 0x5d, 0x1e, 0xe6,
12537	0x36, 0x95, 0x8f, 0x8f, 0x2a, 0xb3, 0x38, 0x81, 0x8e, 0x13, 0xa5, 0xe4, 0x3f, 0x1b, 0x86, 0xc9,
12538	0x48, 0xbc, 0x41, 0x4f, 0x61, 0xae, 0xd5, 0xb3, 0x2c, 0xa2, 0xdb, 0x1b, 0xbd, 0xee, 0x0e, 0xb1,
12539	0x9a, 0xad, 0x3d, 0xd2, 0xee, 0x69, 0xa4, 0xcd, 0x1d, 0x65, 0xa8, 0xbe, 0x20, 0x2c, 0x9e, 0x5b,
12540	0x4a, 0xe4, 0xc2, 0x29, 0xd2, 0x6c, 0x15, 0x74, 0x3e, 0xb4, 0xae, 0x52, 0xea, 0x61, 0xe6, 0x38,
12541	0xa6, 0xb7, 0x0a, 0x1b, 0x31, 0x0e, 0x9c, 0x20, 0xc5, 0x6c, 0x6c, 0x13, 0xaa, 0x5a, 0xa4, 0x1d,
12542	0xb5, 0x31, 0x1f, 0xb6, 0x71, 0x39, 0x91, 0x0b, 0xa7, 0x48, 0xa3, 0xbb, 0x30, 0xea, 0x68, 0xe3,
12543	0xfb, 0x27, 0x36, 0x7a, 0x46, 0x80, 0x8d, 0x6e, 0xf8, 0x24, 0x1c, 0xe4, 0x63, 0x53, 0x33, 0x76,
12544	0x28, 0xb1, 0x0e, 0x48, 0x3b, 0x7d, 0x83, 0x37, 0x63, 0x1c, 0x38, 0x41, 0x8a, 0x4d, 0xcd, 0xf1,
12545	0xc0, 0xd8, 0xd4, 0x86, 0xc3, 0x53, 0xdb, 0x4e, 0xe4, 0xc2, 0x29, 0xd2, 0xcc, 0x8f, 0x1d, 0x93,
12546	0x17, 0x0f, 0x14, 0x55, 0x53, 0x76, 0x34, 0x52, 0x2e, 0x86, 0xfd, 0x78, 0x23, 0x4c, 0xc6, 0x51,
12547	0x7e, 0xf4, 0x18, 0xa6, 0x9d, 0xa1, 0x6d, 0x5d, 0xf1, 0x40, 0x4a, 0x1c, 0xe4, 0x67, 0x02, 0x64,
12548	0x7a, 0x23, 0xca, 0x80, 0xe3, 0x32, 0xe8, 0x01, 0x4c, 0xb4, 0x0c, 0x4d, 0xe3, 0xfe, 0xb8, 0x64,
12549	0xf4, 0x74, 0xbb, 0x3c, 0xc2, 0x51, 0x10, 0x3b, 0x8f, 0x4b, 0x21, 0x0a, 0x8e, 0x70, 0x22, 0x02,
12550	0xd0, 0x72, 0x13, 0x0e, 0x2d, 0x03, 0x8f, 0x8f, 0xb7, 0xb2, 0xc6, 0x00, 0x2f, 0x55, 0xf9, 0x35,
12551	0x80, 0x37, 0x44, 0x71, 0x00, 0x58, 0xfe, 0x67, 0x09, 0xe6, 0x53, 0x42, 0x07, 0x7a, 0x37, 0x94,
12552	0x62, 0x7f, 0x35, 0x92, 0x62, 0x2f, 0xa7, 0x88, 0x05, 0xf2, 0xac, 0x0e, 0xe3, 0x16, 0x9b, 0x95,
12553	0xde, 0x71, 0x58, 0x44, 0x8c, 0xbc, 0x3b, 0x60, 0x1a, 0x38, 0x28, 0xe3, 0xc7, 0xfc, 0xe9, 0xe3,
12554	0xa3, 0xca, 0x78, 0x88, 0x86, 0xc3, 0xf0, 0xf2, 0x9f, 0xe7, 0x00, 0x96, 0x89, 0xa9, 0x19, 0xfd,
12555	0x2e, 0xd1, 0xcf, 0xa3, 0x86, 0xda, 0x0c, 0xd5, 0x50, 0x37, 0x07, 0x6d, 0x8f, 0x67, 0x5a, 0x6a,
12556	0x11, 0xf5, 0x9b, 0x91, 0x22, 0xaa, 0x96, 0x1d, 0xf2, 0xe4, 0x2a, 0xea, 0xdf, 0xf2, 0x30, 0xe3,
12557	0x33, 0xfb, 0x65, 0xd4, 0xc3, 0xd0, 0x1e, 0xff, 0x4a, 0x64, 0x8f, 0xe7, 0x13, 0x44, 0x5e, 0x59,
12558	0x1d, 0xf5, 0xf2, 0xeb, 0x19, 0xf4, 0x0c, 0x26, 0x58, 0xe1, 0xe4, 0xb8, 0x07, 0x2f, 0xcb, 0x86,
12559	0x4f, 0x5d, 0x96, 0x79, 0x09, 0x74, 0x2d, 0x84, 0x84, 0x23, 0xc8, 0x29, 0x65, 0x60, 0xf1, 0x55,
12560	0x97, 0x81, 0xf2, 0xd7, 0x12, 0x4c, 0xf8, 0xdb, 0x74, 0x0e, 0x45, 0xdb, 0x46, 0xb8, 0x68, 0x7b,
12561	0x23, 0xb3, 0x8b, 0xa6, 0x54, 0x6d, 0xff, 0xcd, 0x0a, 0x7c, 0x8f, 0x89, 0x1d, 0xf0, 0x1d, 0xa5,
12562	0xb5, 0x3f, 0xf8, 0x8e, 0x87, 0xbe, 0x90, 0x00, 0x89, 0x2c, 0xb0, 0xa8, 0xeb, 0x86, 0xad, 0x38,
12563	0xb1, 0xd2, 0x31, 0x6b, 0x35, 0xb3, 0x59, 0xae, 0xc6, 0xea, 0x76, 0x0c, 0xeb, 0x91, 0x6e, 0x5b,
12564	0x7d, 0x7f, 0x47, 0xe2, 0x0c, 0x38, 0xc1, 0x00, 0xa4, 0x00, 0x58, 0x02, 0x73, 0xcb, 0x10, 0x07,
12565	0xf9, 0x66, 0x86, 0x98, 0xc7, 0x04, 0x96, 0x0c, 0x7d, 0x57, 0xed, 0xf8, 0x61, 0x07, 0x7b, 0x40,
12566	0x38, 0x00, 0x7a, 0xe9, 0x11, 0xcc, 0xa7, 0x58, 0x8b, 0xa6, 0x20, 0xbf, 0x4f, 0xfa, 0xce, 0xb2,
12567	0x61, 0xf6, 0x27, 0x9a, 0x85, 0xa1, 0x03, 0x45, 0xeb, 0x39, 0xe1, 0x77, 0x04, 0x3b, 0x3f, 0x1e,
12568	0xe4, 0xee, 0x4b, 0xf2, 0x57, 0x43, 0x41, 0xdf, 0xe1, 0x15, 0xf3, 0x75, 0x76, 0x69, 0x35, 0x35,
12569	0xb5, 0xa5, 0x50, 0x51, 0x08, 0x8d, 0x39, 0x17, 0x56, 0x67, 0x0c, 0x7b, 0xd4, 0x50, 0x6d, 0x9d,
12570	0x7b, 0xb5, 0xb5, 0x75, 0xfe, 0xe5, 0xd4, 0xd6, 0xbf, 0x0d, 0x25, 0xea, 0x56, 0xd5, 0x05, 0x0e,
12571	0x79, 0xeb, 0x14, 0xf1, 0x55, 0x14, 0xd4, 0x9e, 0x02, 0xaf, 0x94, 0xf6, 0x40, 0x93, 0x8a, 0xe8,
12572	0xa1, 0x53, 0x16, 0xd1, 0x2f, 0xb5, 0xf0, 0x65, 0x31, 0xd5, 0x54, 0x7a, 0x94, 0xb4, 0x79, 0x20,
12573	0x2a, 0xf9, 0x31, 0xb5, 0xc1, 0x47, 0xb1, 0xa0, 0xa2, 0x8f, 0x43, 0x2e, 0x5b, 0x3a, 0x8b, 0xcb,
12574	0x4e, 0xa4, 0xbb, 0x2b, 0xda, 0x86, 0x79, 0xd3, 0x32, 0x3a, 0x16, 0xa1, 0x74, 0x99, 0x28, 0x6d,
12575	0x4d, 0xd5, 0x89, 0xbb, 0x3e, 0x4e, 0x45, 0x74, 0xf9, 0xf8, 0xa8, 0x32, 0xdf, 0x48, 0x66, 0xc1,
12576	0x69, 0xb2, 0xf2, 0xf3, 0x02, 0x4c, 0x45, 0x33, 0x60, 0x4a, 0x91, 0x2a, 0x9d, 0xa9, 0x48, 0xbd,
12577	0x11, 0x38, 0x0c, 0x4e, 0x05, 0x1f, 0x78, 0xc1, 0x89, 0x1d, 0x88, 0x45, 0x98, 0x14, 0xd1, 0xc0,
12578	0x25, 0x8a, 0x32, 0xdd, 0xdb, 0xfd, 0xed, 0x30, 0x19, 0x47, 0xf9, 0x59, 0xe9, 0xe9, 0x57, 0x94,
12579	0x2e, 0x48, 0x21, 0x5c, 0x7a, 0x2e, 0x46, 0x19, 0x70, 0x5c, 0x06, 0xad, 0xc3, 0x4c, 0x4f, 0x8f,
12580	0x43, 0x39, 0xde, 0x78, 0x59, 0x40, 0xcd, 0x6c, 0xc7, 0x59, 0x70, 0x92, 0x1c, 0xda, 0x0d, 0x55,
12581	0xa3, 0xc3, 0x3c, 0xc2, 0xde, 0xce, 0x7c, 0x76, 0x32, 0x97, 0xa3, 0xe8, 0x21, 0x8c, 0x5b, 0xfc,
12582	0xde, 0xe1, 0x1a, 0xec, 0xd4, 0xee, 0x17, 0x85, 0xd8, 0x38, 0x0e, 0x12, 0x71, 0x98, 0x37, 0xa1,
12583	0xdc, 0x2e, 0x65, 0x2d, 0xb7, 0xe5, 0x7f, 0x94, 0x82, 0x49, 0xc8, 0x2b, 0x81, 0x07, 0xbd, 0x32,
12584	0xc5, 0x24, 0x02, 0xd5, 0x91, 0x91, 0x5c, 0xfd, 0xde, 0x3b, 0x55, 0xf5, 0xeb, 0x27, 0xcf, 0xc1,
12585	0xe5, 0xef, 0x97, 0x12, 0xcc, 0xad, 0x34, 0x1f, 0x5b, 0x46, 0xcf, 0x74, 0xcd, 0xd9, 0x34, 0x9d,
12586	0x75, 0xfd, 0x05, 0x14, 0xac, 0x9e, 0xe6, 0xce, 0xe3, 0x75, 0x77, 0x1e, 0xb8, 0xa7, 0xb1, 0x79,
12587	0xcc, 0x44, 0xa4, 0x9c, 0x49, 0x30, 0x01, 0xb4, 0x01, 0xc3, 0x96, 0xa2, 0x77, 0x88, 0x9b, 0x56,
12588	0xaf, 0x0d, 0xb0, 0x7e, 0x75, 0x19, 0x33, 0xf6, 0x40, 0xf1, 0xc6, 0xa5, 0xb1, 0x40, 0x91, 0xff,
12589	0x48, 0x82, 0xc9, 0x27, 0x5b, 0x5b, 0x8d, 0x55, 0x9d, 0x9f, 0x68, 0xfe, 0xb6, 0x7a, 0x15, 0x0a,
12590	0xa6, 0x62, 0xef, 0x45, 0x33, 0x3d, 0xa3, 0x61, 0x4e, 0x41, 0x1f, 0x42, 0x91, 0x45, 0x12, 0xa2,
12591	0xb7, 0x33, 0x96, 0xda, 0x02, 0xbe, 0xee, 0x08, 0xf9, 0x15, 0xa2, 0x18, 0xc0, 0x2e, 0x9c, 0xbc,
12592	0x0f, 0xb3, 0x01, 0x73, 0xd8, 0x7a, 0x3c, 0x65, 0xd9, 0x11, 0x35, 0x61, 0x88, 0x69, 0x66, 0x39,
12593	0x30, 0x9f, 0xe1, 0x31, 0x33, 0x32, 0x25, 0xbf, 0xd2, 0x61, 0xbf, 0x28, 0x76, 0xb0, 0xe4, 0x75,
12594	0x18, 0xe7, 0x0f, 0xca, 0x86, 0x65, 0xf3, 0x65, 0x41, 0x57, 0x20, 0xdf, 0x55, 0x75, 0x91, 0x67,
12595	0x47, 0x85, 0x4c, 0x9e, 0xe5, 0x08, 0x36, 0xce, 0xc9, 0xca, 0xa1, 0x88, 0x3c, 0x3e, 0x59, 0x39,
12596	0xc4, 0x6c, 0x5c, 0x7e, 0x0c, 0x45, 0xb1, 0xdc, 0x41, 0xa0, 0xfc, 0xc9, 0x40, 0xf9, 0x04, 0xa0,
12597	0x4d, 0x28, 0xae, 0x36, 0xea, 0x9a, 0xe1, 0x54, 0x5d, 0x2d, 0xb5, 0x6d, 0x45, 0xf7, 0x62, 0x69,
12598	0x75, 0x19, 0x63, 0x4e, 0x41, 0x32, 0x0c, 0x93, 0xc3, 0x16, 0x31, 0x6d, 0xee, 0x11, 0x23, 0x75,
12599	0x60, 0xbb, 0xfc, 0x88, 0x8f, 0x60, 0x41, 0x91, 0xff, 0x38, 0x07, 0x45, 0xb1, 0x1c, 0xe7, 0x70,
12600	0x0b, 0x5b, 0x0b, 0xdd, 0xc2, 0xde, 0xcc, 0xe6, 0x1a, 0xa9, 0x57, 0xb0, 0xad, 0xc8, 0x15, 0xec,
12601	0x46, 0x46, 0xbc, 0x93, 0xef, 0x5f, 0x7f, 0x27, 0xc1, 0x44, 0xd8, 0x29, 0xd1, 0x5d, 0x18, 0x65,
12602	0x09, 0x47, 0x6d, 0x91, 0x0d, 0xbf, 0xce, 0xf5, 0x1e, 0x61, 0x9a, 0x3e, 0x09, 0x07, 0xf9, 0x50,
12603	0xc7, 0x13, 0x63, 0x7e, 0x24, 0x26, 0x9d, 0xbe, 0xa4, 0x3d, 0x5b, 0xd5, 0xaa, 0xce, 0xa7, 0x95,
12604	0xea, 0xaa, 0x6e, 0x6f, 0x5a, 0x4d, 0xdb, 0x52, 0xf5, 0x4e, 0x4c, 0x11, 0x77, 0xca, 0x20, 0xb2,
12605	0xfc, 0x0f, 0x12, 0x8c, 0x0a, 0x93, 0xcf, 0xe1, 0x56, 0xf1, 0x1b, 0xe1, 0x5b, 0xc5, 0xb5, 0x8c,
12606	0x07, 0x3c, 0xf9, 0x4a, 0xf1, 0x57, 0xbe, 0xe9, 0xec, 0x48, 0x33, 0xaf, 0xde, 0x33, 0xa8, 0x1d,
12607	0xf5, 0x6a, 0x76, 0x18, 0x31, 0xa7, 0xa0, 0x1e, 0x4c, 0xa9, 0x91, 0x18, 0x20, 0x96, 0xb6, 0x96,
12608	0xcd, 0x12, 0x4f, 0xac, 0x5e, 0x16, 0xf0, 0x53, 0x51, 0x0a, 0x8e, 0xa9, 0x90, 0x09, 0xc4, 0xb8,
12609	0xd0, 0x07, 0x50, 0xd8, 0xb3, 0x6d, 0x33, 0xe1, 0xbd, 0x7a, 0x40, 0xe4, 0xf1, 0x4d, 0x28, 0xf1,
12610	0xd9, 0x6d, 0x6d, 0x35, 0x30, 0x87, 0x92, 0xff, 0xc7, 0x5f, 0x8f, 0xa6, 0xe3, 0xe3, 0x5e, 0x3c,
12611	0x95, 0xce, 0x12, 0x4f, 0x47, 0x93, 0x62, 0x29, 0x7a, 0x02, 0x79, 0x5b, 0xcb, 0x7a, 0x2d, 0x14,
12612	0x88, 0x5b, 0x6b, 0x4d, 0x3f, 0x20, 0x6d, 0xad, 0x35, 0x31, 0x83, 0x40, 0x9b, 0x30, 0xc4, 0xb2,
12613	0x0f, 0x3b, 0x82, 0xf9, 0xec, 0x47, 0x9a, 0xcd, 0xdf, 0x77, 0x08, 0xf6, 0x8b, 0x62, 0x07, 0x47,
12614	0xfe, 0x0c, 0xc6, 0x43, 0xe7, 0x14, 0x7d, 0x0a, 0x63, 0x9a, 0xa1, 0xb4, 0xeb, 0x8a, 0xa6, 0xe8,
12615	0x2d, 0xe2, 0x7e, 0x1c, 0xb8, 0x96, 0x74, 0xc3, 0x58, 0x0b, 0xf0, 0x89, 0x53, 0x3e, 0x2b, 0x94,
12616	0x8c, 0x05, 0x69, 0x38, 0x84, 0x28, 0x2b, 0x00, 0xfe, 0x1c, 0x51, 0x05, 0x86, 0x98, 0x9f, 0x39,
12617	0xf9, 0x64, 0xa4, 0x3e, 0xc2, 0x2c, 0x64, 0xee, 0x47, 0xb1, 0x33, 0x8e, 0x6e, 0x03, 0x50, 0xd2,
12618	0xb2, 0x88, 0xcd, 0x83, 0x41, 0x2e, 0xfc, 0x81, 0xb1, 0xe9, 0x51, 0x70, 0x80, 0x4b, 0xfe, 0x27,
12619	0x09, 0xc6, 0x37, 0x88, 0xfd, 0xb9, 0x61, 0xed, 0x37, 0x0c, 0x4d, 0x6d, 0xf5, 0xcf, 0x21, 0xd8,
12620	0xe2, 0x50, 0xb0, 0x7d, 0x6b, 0xc0, 0xce, 0x84, 0xac, 0x4b, 0x0b, 0xb9, 0xf2, 0xd7, 0x12, 0xcc,
12621	0x87, 0x38, 0x1f, 0xf9, 0x47, 0x77, 0x1b, 0x86, 0x4c, 0xc3, 0xb2, 0xdd, 0x44, 0x7c, 0x2a, 0x85,
12622	0x2c, 0x8c, 0x05, 0x52, 0x31, 0x83, 0xc1, 0x0e, 0x1a, 0x5a, 0x83, 0x9c, 0x6d, 0x08, 0x57, 0x3d,
12623	0x1d, 0x26, 0x21, 0x56, 0x1d, 0x04, 0x66, 0x6e, 0xcb, 0xc0, 0x39, 0xdb, 0x60, 0x1b, 0x51, 0x0e,
12624	0x71, 0x05, 0x83, 0xcf, 0x2b, 0x9a, 0x01, 0x86, 0xc2, 0xae, 0x65, 0x74, 0xcf, 0x3c, 0x07, 0x6f,
12625	0x23, 0x56, 0x2c, 0xa3, 0x8b, 0x39, 0x96, 0xfc, 0x8d, 0x04, 0xd3, 0x21, 0xce, 0x73, 0x08, 0xfc,
12626	0x1f, 0x84, 0x03, 0xff, 0x8d, 0xd3, 0x4c, 0x24, 0x25, 0xfc, 0x7f, 0x93, 0x8b, 0x4c, 0x83, 0x4d,
12627	0x18, 0xed, 0xc2, 0xa8, 0x69, 0xb4, 0x9b, 0x2f, 0xe1, 0x73, 0xe0, 0x24, 0xcb, 0x9b, 0x0d, 0x1f,
12628	0x0b, 0x07, 0x81, 0xd1, 0x21, 0x4c, 0xeb, 0x4a, 0x97, 0x50, 0x53, 0x69, 0x91, 0xe6, 0x4b, 0x78,
12629	0x20, 0xb9, 0xc8, 0xbf, 0x37, 0x44, 0x11, 0x71, 0x5c, 0x09, 0x5a, 0x87, 0xa2, 0x6a, 0xf2, 0x3a,
12630	0x4e, 0xd4, 0x2e, 0x03, 0xb3, 0xa8, 0x53, 0xf5, 0x39, 0xf1, 0x5c, 0xfc, 0xc0, 0x2e, 0x86, 0xfc,
12631	0xd7, 0x51, 0x6f, 0x60, 0xfe, 0x87, 0x1e, 0x43, 0x89, 0x37, 0x66, 0xb4, 0x0c, 0xcd, 0xfd, 0x32,
12632	0xc0, 0x76, 0xb6, 0x21, 0xc6, 0x5e, 0x1c, 0x55, 0x2e, 0x27, 0x3c, 0xfa, 0xba, 0x64, 0xec, 0x09,
12633	0xa3, 0x0d, 0x28, 0x98, 0x3f, 0xa5, 0x82, 0xe1, 0x49, 0x8e, 0x97, 0x2d, 0x1c, 0x47, 0xfe, 0xbd,
12634	0x7c, 0xc4, 0x5c, 0x9e, 0xea, 0x9e, 0xbd, 0xb4, 0x5d, 0xf7, 0x2a, 0xa6, 0xd4, 0x9d, 0xdf, 0x81,
12635	0xa2, 0xc8, 0xf0, 0xc2, 0x99, 0x7f, 0x71, 0x1a, 0x67, 0x0e, 0x66, 0x31, 0xef, 0xc2, 0xe2, 0x0e,
12636	0xba, 0xc0, 0xe8, 0x13, 0x18, 0x26, 0x8e, 0x0a, 0x27, 0x37, 0xde, 0x3b, 0x8d, 0x0a, 0x3f, 0xae,
12637	0xfa, 0x85, 0xaa, 0x18, 0x13, 0xa8, 0xe8, 0x5d, 0xb6, 0x5e, 0x8c, 0x97, 0x5d, 0x02, 0x69, 0xb9,
12638	0xc0, 0xd3, 0xd5, 0x15, 0x67, 0xda, 0xde, 0xf0, 0x8b, 0xa3, 0x0a, 0xf8, 0x3f, 0x71, 0x50, 0x42,
12639	0xfe, 0x17, 0x09, 0xa6, 0xf9, 0x0a, 0xb5, 0x7a, 0x96, 0x6a, 0xf7, 0xcf, 0x2d, 0x31, 0x3d, 0x0d,
12640	0x25, 0xa6, 0x3b, 0x03, 0x96, 0x25, 0x66, 0x61, 0x6a, 0x72, 0xfa, 0x56, 0x82, 0x8b, 0x31, 0xee,
12641	0x73, 0x88, 0x8b, 0xdb, 0xe1, 0xb8, 0xf8, 0xd6, 0x69, 0x27, 0x94, 0x12, 0x1b, 0xff, 0x6b, 0x3a,
12642	0x61, 0x3a, 0xfc, 0xa4, 0xdc, 0x06, 0x30, 0x2d, 0xf5, 0x40, 0xd5, 0x48, 0x47, 0x7c, 0x04, 0x2f,
12643	0x05, 0x5a, 0x9c, 0x3c, 0x0a, 0x0e, 0x70, 0x21, 0x0a, 0x73, 0x6d, 0xb2, 0xab, 0xf4, 0x34, 0x7b,
12644	0xb1, 0xdd, 0x5e, 0x52, 0x4c, 0x65, 0x47, 0xd5, 0x54, 0x5b, 0x15, 0xcf, 0x05, 0x23, 0xf5, 0x87,
12645	0xce, 0xc7, 0xe9, 0x24, 0x8e, 0x17, 0x47, 0x95, 0x2b, 0x49, 0x5f, 0x87, 0x5c, 0x96, 0x3e, 0x4e,
12646	0x81, 0x46, 0x7d, 0x28, 0x5b, 0xe4, 0xb3, 0x9e, 0x6a, 0x91, 0xf6, 0xb2, 0x65, 0x98, 0x21, 0xb5,
12647	0x79, 0xae, 0xf6, 0xd7, 0x8f, 0x8f, 0x2a, 0x65, 0x9c, 0xc2, 0x33, 0x58, 0x71, 0x2a, 0x3c, 0x7a,
12648	0x06, 0x33, 0x8a, 0x68, 0x46, 0x0b, 0x6a, 0x75, 0x4e, 0xc9, 0xfd, 0xe3, 0xa3, 0xca, 0xcc, 0x62,
12649	0x9c, 0x3c, 0x58, 0x61, 0x12, 0x28, 0xaa, 0x41, 0xf1, 0x80, 0xf7, 0xad, 0xd1, 0xf2, 0x10, 0xc7,
12650	0x67, 0x89, 0xa0, 0xe8, 0xb4, 0xb2, 0x31, 0xcc, 0xe1, 0x95, 0x26, 0x3f, 0x7d, 0x2e, 0x17, 0xbb,
12651	0x50, 0xb2, 0x5a, 0x52, 0x9c, 0x78, 0xfe, 0x62, 0x5c, 0xf2, 0xa3, 0xd6, 0x13, 0x9f, 0x84, 0x83,
12652	0x7c, 0xe8, 0x63, 0x18, 0xd9, 0x13, 0xaf, 0x12, 0xb4, 0x5c, 0xcc, 0x94, 0x84, 0x43, 0xaf, 0x18,
12653	0xf5, 0x69, 0xa1, 0x62, 0xc4, 0x1d, 0xa6, 0xd8, 0x47, 0x44, 0x6f, 0x40, 0x91, 0xff, 0x58, 0x5d,
12654	0xe6, 0xcf, 0x71, 0x25, 0x3f, 0xb6, 0x3d, 0x71, 0x86, 0xb1, 0x4b, 0x77, 0x59, 0x57, 0x1b, 0x4b,
12655	0xfc, 0x59, 0x38, 0xc2, 0xba, 0xda, 0x58, 0xc2, 0x2e, 0x1d, 0x7d, 0x0a, 0x45, 0x4a, 0xd6, 0x54,
12656	0xbd, 0x77, 0x58, 0x86, 0x4c, 0x1f, 0x95, 0x9b, 0x8f, 0x38, 0x77, 0xe4, 0x61, 0xcc, 0xd7, 0x20,
12657	0xe8, 0xd8, 0x85, 0x45, 0x7b, 0x30, 0x62, 0xf5, 0xf4, 0x45, 0xba, 0x4d, 0x89, 0x55, 0x1e, 0xe5,
12658	0x3a, 0x06, 0x85, 0x73, 0xec, 0xf2, 0x47, 0xb5, 0x78, 0x2b, 0xe4, 0x71, 0x60, 0x1f, 0x1c, 0xfd,
12659	0xa1, 0x04, 0x88, 0xf6, 0x4c, 0x53, 0x23, 0x5d, 0xa2, 0xdb, 0x8a, 0xc6, 0xdf, 0xe2, 0x68, 0x79,
12660	0x8c, 0xeb, 0x7c, 0x6f, 0xd0, 0xbc, 0x62, 0x82, 0x51, 0xe5, 0xde, 0xa3, 0x77, 0x9c, 0x15, 0x27,
12661	0xe8, 0x65, 0x4b, 0xbb, 0x4b, 0xf9, 0xdf, 0xe5, 0xf1, 0x4c, 0x4b, 0x9b, 0xfc, 0xe6, 0xe8, 0x2f,
12662	0xad, 0xa0, 0x63, 0x17, 0x16, 0x3d, 0x85, 0x39, 0xb7, 0xed, 0x11, 0x1b, 0x86, 0xbd, 0xa2, 0x6a,
12663	0x84, 0xf6, 0xa9, 0x4d, 0xba, 0xe5, 0x09, 0xbe, 0xed, 0x5e, 0xef, 0x07, 0x4e, 0xe4, 0xc2, 0x29,
12664	0xd2, 0xa8, 0x0b, 0x15, 0x37, 0x64, 0xb0, 0xf3, 0xe4, 0xc5, 0xac, 0x47, 0xb4, 0xa5, 0x68, 0xce,
12665	0x77, 0x80, 0x49, 0xae, 0xe0, 0xf5, 0xe3, 0xa3, 0x4a, 0x65, 0xf9, 0x64, 0x56, 0x3c, 0x08, 0x0b,
12666	0x7d, 0x08, 0x65, 0x25, 0x4d, 0xcf, 0x14, 0xd7, 0xf3, 0x1a, 0x8b, 0x43, 0xa9, 0x0a, 0x52, 0xa5,
12667	0x91, 0x0d, 0x53, 0x4a, 0xb8, 0x01, 0x95, 0x96, 0xa7, 0x33, 0x3d, 0x44, 0x46, 0xfa, 0x56, 0xfd,
12668	0xc7, 0x88, 0x08, 0x81, 0xe2, 0x98, 0x06, 0xf4, 0x3b, 0x80, 0x94, 0x68, 0xcf, 0x2c, 0x2d, 0xa3,
12669	0x4c, 0xe9, 0x27, 0xd6, 0x6c, 0xeb, 0xbb, 0x5d, 0x8c, 0x44, 0x71, 0x82, 0x1e, 0xb4, 0x06, 0xb3,
12670	0x62, 0x74, 0x5b, 0xa7, 0xca, 0x2e, 0x69, 0xf6, 0x69, 0xcb, 0xd6, 0x68, 0x79, 0x86, 0xc7, 0x3e,
12671	0xfe, 0xe1, 0x6b, 0x31, 0x81, 0x8e, 0x13, 0xa5, 0xd0, 0x7b, 0x30, 0xb5, 0x6b, 0x58, 0x3b, 0x6a,
12672	0xbb, 0x4d, 0x74, 0x17, 0x69, 0x96, 0x23, 0xcd, 0xb2, 0xd5, 0x58, 0x89, 0xd0, 0x70, 0x8c, 0x1b,
12673	0x51, 0xb8, 0x28, 0x90, 0x1b, 0x96, 0xd1, 0x5a, 0x37, 0x7a, 0xba, 0xed, 0x94, 0x44, 0x17, 0xbd,
12674	0x14, 0x73, 0x71, 0x31, 0x89, 0xe1, 0xc5, 0x51, 0xe5, 0x6a, 0x72, 0x05, 0xec, 0x33, 0xe1, 0x64,
12675	0x6c, 0xb4, 0x07, 0xc0, 0xe3, 0x82, 0x73, 0xfc, 0xe6, 0xf8, 0xf1, 0xbb, 0x9f, 0x25, 0xea, 0x24,
12676	0x9e, 0x40, 0xe7, 0x93, 0x9c, 0x47, 0xc6, 0x01, 0x6c, 0x76, 0x4b, 0x51, 0x22, 0x6d, 0xd5, 0xb4,
12677	0x3c, 0xcf, 0xf7, 0xba, 0x96, 0x6d, 0xaf, 0x3d, 0xb9, 0xc0, 0xa7, 0xa9, 0x28, 0x22, 0x8e, 0x2b,
12678	0x41, 0x26, 0x8c, 0x89, 0x3e, 0xf1, 0x25, 0x4d, 0xa1, 0xb4, 0x5c, 0xe6, 0xb3, 0x7c, 0x30, 0x78,
12679	0x96, 0x9e, 0x48, 0x74, 0x9e, 0x53, 0xc7, 0x47, 0x95, 0xb1, 0x20, 0x03, 0x0e, 0x69, 0xe0, 0x7d,
12680	0x41, 0xe2, 0x2b, 0xd1, 0xf9, 0xf4, 0x56, 0x9f, 0xae, 0x2f, 0xc8, 0x37, 0xed, 0xa5, 0xf5, 0x05,
12681	0x05, 0x20, 0x4f, 0x7e, 0x97, 0xfe, 0xcf, 0x1c, 0xcc, 0xf8, 0xcc, 0x99, 0xfb, 0x82, 0x12, 0x44,
12682	0x7e, 0xd9, 0x5f, 0x3d, 0xb8, 0xbf, 0xfa, 0x6b, 0x09, 0x26, 0xfc, 0xa5, 0xfb, 0xbf, 0xd7, 0xab,
12683	0xe3, 0xdb, 0x96, 0x72, 0x7b, 0xf8, 0xdb, 0x5c, 0x70, 0x02, 0xff, 0xef, 0x1b, 0x46, 0x7e, 0x7a,
12684	0x53, 0xb4, 0xfc, 0x6d, 0x1e, 0xa6, 0xa2, 0xa7, 0x31, 0xd4, 0x57, 0x20, 0x0d, 0xec, 0x2b, 0x68,
12685	0xc0, 0xec, 0x6e, 0x4f, 0xd3, 0xfa, 0x7c, 0x19, 0x02, 0xcd, 0x05, 0xce, 0x77, 0xc1, 0xd7, 0x84,
12686	0xe4, 0xec, 0x4a, 0x02, 0x0f, 0x4e, 0x94, 0x4c, 0xe9, 0x91, 0xc8, 0x9f, 0xa9, 0x47, 0x22, 0xf6,
12687	0xc9, 0xbe, 0x70, 0x8a, 0x4f, 0xf6, 0x89, 0xfd, 0x0e, 0x43, 0x67, 0xe8, 0x77, 0x38, 0x4b, 0x83,
12688	0x42, 0x42, 0x10, 0x1b, 0xd8, 0x2f, 0xfb, 0x1a, 0x5c, 0x12, 0x62, 0x36, 0xef, 0x1d, 0xd0, 0x6d,
12689	0xcb, 0xd0, 0x34, 0x62, 0x2d, 0xf7, 0xba, 0xdd, 0xbe, 0xfc, 0x0e, 0x4c, 0x84, 0xbb, 0x62, 0x9c,
12690	0x9d, 0x76, 0x1a, 0x73, 0xc4, 0xd7, 0xd9, 0xc0, 0x4e, 0x3b, 0xe3, 0xd8, 0xe3, 0x90, 0x7f, 0x5f,
12691	0x82, 0xb9, 0xe4, 0xee, 0x57, 0xa4, 0xc1, 0x44, 0x57, 0x39, 0x0c, 0x76, 0x24, 0x4b, 0x67, 0x7c,
12692	0x37, 0xe3, 0xed, 0x10, 0xeb, 0x21, 0x2c, 0x1c, 0xc1, 0x96, 0x7f, 0x94, 0x60, 0x3e, 0xa5, 0x11,
12693	0xe1, 0x7c, 0x2d, 0x41, 0x1f, 0x41, 0xa9, 0xab, 0x1c, 0x36, 0x7b, 0x56, 0x87, 0x9c, 0xf9, 0xa5,
12694	0x90, 0x47, 0x8c, 0x75, 0x81, 0x82, 0x3d, 0x3c, 0xf9, 0x2f, 0x25, 0xf8, 0x59, 0x6a, 0xf5, 0x84,
12695	0xee, 0x85, 0x7a, 0x26, 0xe4, 0x48, 0xcf, 0x04, 0x8a, 0x0b, 0xbe, 0xa2, 0x96, 0x89, 0x2f, 0x25,
12696	0x28, 0xa7, 0xdd, 0x2c, 0xd1, 0xdd, 0x90, 0x91, 0x3f, 0x8f, 0x18, 0x39, 0x1d, 0x93, 0x7b, 0x45,
12697	0x36, 0xfe, 0xab, 0x04, 0x97, 0x4f, 0xa8, 0xd0, 0xbc, 0xab, 0x12, 0x69, 0x07, 0xb9, 0xf8, 0xa3,
12698	0xb6, 0xf8, 0x22, 0xe6, 0x5f, 0x95, 0x12, 0x78, 0x70, 0xaa, 0x34, 0xda, 0x86, 0x79, 0x71, 0x4f,
12699	0x8b, 0xd2, 0x44, 0xf1, 0xc1, 0x5b, 0xcb, 0x96, 0x93, 0x59, 0x70, 0x9a, 0xac, 0xfc, 0x37, 0x12,
12700	0xcc, 0x25, 0x3f, 0x19, 0xa0, 0xb7, 0x43, 0x4b, 0x5e, 0x89, 0x2c, 0xf9, 0x64, 0x44, 0x4a, 0x2c,
12701	0xf8, 0x27, 0x30, 0x21, 0x1e, 0x16, 0x04, 0x8c, 0x70, 0x66, 0x39, 0x29, 0x45, 0x09, 0x08, 0xb7,
12702	0xbc, 0xe5, 0xc7, 0x24, 0x3c, 0x86, 0x23, 0x68, 0xf2, 0x1f, 0xe4, 0x60, 0xa8, 0xd9, 0x52, 0x34,
12703	0x72, 0x0e, 0xd5, 0xed, 0xfb, 0xa1, 0xea, 0x76, 0xd0, 0x3f, 0x6d, 0x71, 0xab, 0x52, 0x0b, 0x5b,
12704	0x1c, 0x29, 0x6c, 0xdf, 0xcc, 0x84, 0x76, 0x72, 0x4d, 0xfb, 0x6b, 0x30, 0xe2, 0x29, 0x3d, 0x5d,
12705	0xaa, 0x95, 0xff, 0x22, 0x07, 0xa3, 0x01, 0x15, 0xa7, 0x4c, 0xd4, 0xbb, 0xa1, 0x02, 0x27, 0x9f,
12706	0xe1, 0xee, 0x16, 0xd0, 0x55, 0x75, 0x4b, 0x1a, 0xa7, 0xe9, 0xd8, 0x6f, 0x33, 0x8d, 0x57, 0x3a,
12707	0xef, 0xc0, 0x84, 0xad, 0x58, 0x1d, 0x62, 0x7b, 0x9f, 0x35, 0xf2, 0xdc, 0x17, 0xbd, 0x56, 0xf5,
12708	0xad, 0x10, 0x15, 0x47, 0xb8, 0x2f, 0x3d, 0x84, 0xf1, 0x90, 0xb2, 0x53, 0xf5, 0x0c, 0xff, 0xbd,
12709	0x04, 0x3f, 0x1f, 0xf8, 0xe8, 0x84, 0xea, 0xa1, 0x43, 0x52, 0x8d, 0x1c, 0x92, 0x85, 0x74, 0x80,
12710	0x57, 0xd7, 0x7b, 0x56, 0xbf, 0xf9, 0xfc, 0x87, 0x85, 0x0b, 0xdf, 0xfd, 0xb0, 0x70, 0xe1, 0xfb,
12711	0x1f, 0x16, 0x2e, 0xfc, 0xee, 0xf1, 0x82, 0xf4, 0xfc, 0x78, 0x41, 0xfa, 0xee, 0x78, 0x41, 0xfa,
12712	0xfe, 0x78, 0x41, 0xfa, 0xf7, 0xe3, 0x05, 0xe9, 0x4f, 0x7e, 0x5c, 0xb8, 0xf0, 0x51, 0x51, 0xc0,
12713	0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xd0, 0x60, 0xbe, 0x07, 0x3e, 0x00, 0x00,
12714}
12715