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		SELinuxStrategyOptions
79		Scale
80		ScaleSpec
81		ScaleStatus
82		SupplementalGroupsStrategyOptions
83*/
84package v1beta1
85
86import proto "github.com/gogo/protobuf/proto"
87import fmt "fmt"
88import math "math"
89
90import k8s_io_api_core_v1 "k8s.io/api/core/v1"
91import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
92
93import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
94
95import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
96
97import strings "strings"
98import reflect "reflect"
99
100import io "io"
101
102// Reference imports to suppress errors if they are not otherwise used.
103var _ = proto.Marshal
104var _ = fmt.Errorf
105var _ = math.Inf
106
107// This is a compile-time assertion to ensure that this generated file
108// is compatible with the proto package it is being compiled against.
109// A compilation error at this line likely means your copy of the
110// proto package needs to be updated.
111const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
112
113func (m *AllowedCSIDriver) Reset()                    { *m = AllowedCSIDriver{} }
114func (*AllowedCSIDriver) ProtoMessage()               {}
115func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
116
117func (m *AllowedFlexVolume) Reset()                    { *m = AllowedFlexVolume{} }
118func (*AllowedFlexVolume) ProtoMessage()               {}
119func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
120
121func (m *AllowedHostPath) Reset()                    { *m = AllowedHostPath{} }
122func (*AllowedHostPath) ProtoMessage()               {}
123func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
124
125func (m *DaemonSet) Reset()                    { *m = DaemonSet{} }
126func (*DaemonSet) ProtoMessage()               {}
127func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
128
129func (m *DaemonSetCondition) Reset()                    { *m = DaemonSetCondition{} }
130func (*DaemonSetCondition) ProtoMessage()               {}
131func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
132
133func (m *DaemonSetList) Reset()                    { *m = DaemonSetList{} }
134func (*DaemonSetList) ProtoMessage()               {}
135func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
136
137func (m *DaemonSetSpec) Reset()                    { *m = DaemonSetSpec{} }
138func (*DaemonSetSpec) ProtoMessage()               {}
139func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
140
141func (m *DaemonSetStatus) Reset()                    { *m = DaemonSetStatus{} }
142func (*DaemonSetStatus) ProtoMessage()               {}
143func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
144
145func (m *DaemonSetUpdateStrategy) Reset()                    { *m = DaemonSetUpdateStrategy{} }
146func (*DaemonSetUpdateStrategy) ProtoMessage()               {}
147func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
148
149func (m *Deployment) Reset()                    { *m = Deployment{} }
150func (*Deployment) ProtoMessage()               {}
151func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
152
153func (m *DeploymentCondition) Reset()                    { *m = DeploymentCondition{} }
154func (*DeploymentCondition) ProtoMessage()               {}
155func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
156
157func (m *DeploymentList) Reset()                    { *m = DeploymentList{} }
158func (*DeploymentList) ProtoMessage()               {}
159func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
160
161func (m *DeploymentRollback) Reset()                    { *m = DeploymentRollback{} }
162func (*DeploymentRollback) ProtoMessage()               {}
163func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
164
165func (m *DeploymentSpec) Reset()                    { *m = DeploymentSpec{} }
166func (*DeploymentSpec) ProtoMessage()               {}
167func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
168
169func (m *DeploymentStatus) Reset()                    { *m = DeploymentStatus{} }
170func (*DeploymentStatus) ProtoMessage()               {}
171func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
172
173func (m *DeploymentStrategy) Reset()                    { *m = DeploymentStrategy{} }
174func (*DeploymentStrategy) ProtoMessage()               {}
175func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
176
177func (m *FSGroupStrategyOptions) Reset()                    { *m = FSGroupStrategyOptions{} }
178func (*FSGroupStrategyOptions) ProtoMessage()               {}
179func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
180
181func (m *HTTPIngressPath) Reset()                    { *m = HTTPIngressPath{} }
182func (*HTTPIngressPath) ProtoMessage()               {}
183func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
184
185func (m *HTTPIngressRuleValue) Reset()                    { *m = HTTPIngressRuleValue{} }
186func (*HTTPIngressRuleValue) ProtoMessage()               {}
187func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
188
189func (m *HostPortRange) Reset()                    { *m = HostPortRange{} }
190func (*HostPortRange) ProtoMessage()               {}
191func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
192
193func (m *IDRange) Reset()                    { *m = IDRange{} }
194func (*IDRange) ProtoMessage()               {}
195func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
196
197func (m *IPBlock) Reset()                    { *m = IPBlock{} }
198func (*IPBlock) ProtoMessage()               {}
199func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
200
201func (m *Ingress) Reset()                    { *m = Ingress{} }
202func (*Ingress) ProtoMessage()               {}
203func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
204
205func (m *IngressBackend) Reset()                    { *m = IngressBackend{} }
206func (*IngressBackend) ProtoMessage()               {}
207func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
208
209func (m *IngressList) Reset()                    { *m = IngressList{} }
210func (*IngressList) ProtoMessage()               {}
211func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
212
213func (m *IngressRule) Reset()                    { *m = IngressRule{} }
214func (*IngressRule) ProtoMessage()               {}
215func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
216
217func (m *IngressRuleValue) Reset()                    { *m = IngressRuleValue{} }
218func (*IngressRuleValue) ProtoMessage()               {}
219func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
220
221func (m *IngressSpec) Reset()                    { *m = IngressSpec{} }
222func (*IngressSpec) ProtoMessage()               {}
223func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
224
225func (m *IngressStatus) Reset()                    { *m = IngressStatus{} }
226func (*IngressStatus) ProtoMessage()               {}
227func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
228
229func (m *IngressTLS) Reset()                    { *m = IngressTLS{} }
230func (*IngressTLS) ProtoMessage()               {}
231func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
232
233func (m *NetworkPolicy) Reset()                    { *m = NetworkPolicy{} }
234func (*NetworkPolicy) ProtoMessage()               {}
235func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
236
237func (m *NetworkPolicyEgressRule) Reset()      { *m = NetworkPolicyEgressRule{} }
238func (*NetworkPolicyEgressRule) ProtoMessage() {}
239func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) {
240	return fileDescriptorGenerated, []int{31}
241}
242
243func (m *NetworkPolicyIngressRule) Reset()      { *m = NetworkPolicyIngressRule{} }
244func (*NetworkPolicyIngressRule) ProtoMessage() {}
245func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) {
246	return fileDescriptorGenerated, []int{32}
247}
248
249func (m *NetworkPolicyList) Reset()                    { *m = NetworkPolicyList{} }
250func (*NetworkPolicyList) ProtoMessage()               {}
251func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
252
253func (m *NetworkPolicyPeer) Reset()                    { *m = NetworkPolicyPeer{} }
254func (*NetworkPolicyPeer) ProtoMessage()               {}
255func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
256
257func (m *NetworkPolicyPort) Reset()                    { *m = NetworkPolicyPort{} }
258func (*NetworkPolicyPort) ProtoMessage()               {}
259func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
260
261func (m *NetworkPolicySpec) Reset()                    { *m = NetworkPolicySpec{} }
262func (*NetworkPolicySpec) ProtoMessage()               {}
263func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
264
265func (m *PodSecurityPolicy) Reset()                    { *m = PodSecurityPolicy{} }
266func (*PodSecurityPolicy) ProtoMessage()               {}
267func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
268
269func (m *PodSecurityPolicyList) Reset()                    { *m = PodSecurityPolicyList{} }
270func (*PodSecurityPolicyList) ProtoMessage()               {}
271func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
272
273func (m *PodSecurityPolicySpec) Reset()                    { *m = PodSecurityPolicySpec{} }
274func (*PodSecurityPolicySpec) ProtoMessage()               {}
275func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} }
276
277func (m *ReplicaSet) Reset()                    { *m = ReplicaSet{} }
278func (*ReplicaSet) ProtoMessage()               {}
279func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} }
280
281func (m *ReplicaSetCondition) Reset()                    { *m = ReplicaSetCondition{} }
282func (*ReplicaSetCondition) ProtoMessage()               {}
283func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} }
284
285func (m *ReplicaSetList) Reset()                    { *m = ReplicaSetList{} }
286func (*ReplicaSetList) ProtoMessage()               {}
287func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} }
288
289func (m *ReplicaSetSpec) Reset()                    { *m = ReplicaSetSpec{} }
290func (*ReplicaSetSpec) ProtoMessage()               {}
291func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} }
292
293func (m *ReplicaSetStatus) Reset()                    { *m = ReplicaSetStatus{} }
294func (*ReplicaSetStatus) ProtoMessage()               {}
295func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} }
296
297func (m *ReplicationControllerDummy) Reset()      { *m = ReplicationControllerDummy{} }
298func (*ReplicationControllerDummy) ProtoMessage() {}
299func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) {
300	return fileDescriptorGenerated, []int{45}
301}
302
303func (m *RollbackConfig) Reset()                    { *m = RollbackConfig{} }
304func (*RollbackConfig) ProtoMessage()               {}
305func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} }
306
307func (m *RollingUpdateDaemonSet) Reset()                    { *m = RollingUpdateDaemonSet{} }
308func (*RollingUpdateDaemonSet) ProtoMessage()               {}
309func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{47} }
310
311func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
312func (*RollingUpdateDeployment) ProtoMessage() {}
313func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
314	return fileDescriptorGenerated, []int{48}
315}
316
317func (m *RunAsGroupStrategyOptions) Reset()      { *m = RunAsGroupStrategyOptions{} }
318func (*RunAsGroupStrategyOptions) ProtoMessage() {}
319func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) {
320	return fileDescriptorGenerated, []int{49}
321}
322
323func (m *RunAsUserStrategyOptions) Reset()      { *m = RunAsUserStrategyOptions{} }
324func (*RunAsUserStrategyOptions) ProtoMessage() {}
325func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
326	return fileDescriptorGenerated, []int{50}
327}
328
329func (m *SELinuxStrategyOptions) Reset()                    { *m = SELinuxStrategyOptions{} }
330func (*SELinuxStrategyOptions) ProtoMessage()               {}
331func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{51} }
332
333func (m *Scale) Reset()                    { *m = Scale{} }
334func (*Scale) ProtoMessage()               {}
335func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} }
336
337func (m *ScaleSpec) Reset()                    { *m = ScaleSpec{} }
338func (*ScaleSpec) ProtoMessage()               {}
339func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} }
340
341func (m *ScaleStatus) Reset()                    { *m = ScaleStatus{} }
342func (*ScaleStatus) ProtoMessage()               {}
343func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{54} }
344
345func (m *SupplementalGroupsStrategyOptions) Reset()      { *m = SupplementalGroupsStrategyOptions{} }
346func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
347func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
348	return fileDescriptorGenerated, []int{55}
349}
350
351func init() {
352	proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver")
353	proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume")
354	proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath")
355	proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet")
356	proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition")
357	proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList")
358	proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec")
359	proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus")
360	proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy")
361	proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment")
362	proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition")
363	proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList")
364	proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback")
365	proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec")
366	proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus")
367	proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy")
368	proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions")
369	proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath")
370	proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue")
371	proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange")
372	proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange")
373	proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock")
374	proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress")
375	proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend")
376	proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList")
377	proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule")
378	proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue")
379	proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec")
380	proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus")
381	proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS")
382	proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy")
383	proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule")
384	proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule")
385	proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList")
386	proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer")
387	proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort")
388	proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec")
389	proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy")
390	proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList")
391	proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec")
392	proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet")
393	proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition")
394	proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList")
395	proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec")
396	proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus")
397	proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.api.extensions.v1beta1.ReplicationControllerDummy")
398	proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig")
399	proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet")
400	proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment")
401	proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions")
402	proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions")
403	proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions")
404	proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale")
405	proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec")
406	proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus")
407	proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions")
408}
409func (m *AllowedCSIDriver) Marshal() (dAtA []byte, err error) {
410	size := m.Size()
411	dAtA = make([]byte, size)
412	n, err := m.MarshalTo(dAtA)
413	if err != nil {
414		return nil, err
415	}
416	return dAtA[:n], nil
417}
418
419func (m *AllowedCSIDriver) MarshalTo(dAtA []byte) (int, error) {
420	var i int
421	_ = i
422	var l int
423	_ = l
424	dAtA[i] = 0xa
425	i++
426	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
427	i += copy(dAtA[i:], m.Name)
428	return i, nil
429}
430
431func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) {
432	size := m.Size()
433	dAtA = make([]byte, size)
434	n, err := m.MarshalTo(dAtA)
435	if err != nil {
436		return nil, err
437	}
438	return dAtA[:n], nil
439}
440
441func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) {
442	var i int
443	_ = i
444	var l int
445	_ = l
446	dAtA[i] = 0xa
447	i++
448	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver)))
449	i += copy(dAtA[i:], m.Driver)
450	return i, nil
451}
452
453func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) {
454	size := m.Size()
455	dAtA = make([]byte, size)
456	n, err := m.MarshalTo(dAtA)
457	if err != nil {
458		return nil, err
459	}
460	return dAtA[:n], nil
461}
462
463func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) {
464	var i int
465	_ = i
466	var l int
467	_ = l
468	dAtA[i] = 0xa
469	i++
470	i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix)))
471	i += copy(dAtA[i:], m.PathPrefix)
472	dAtA[i] = 0x10
473	i++
474	if m.ReadOnly {
475		dAtA[i] = 1
476	} else {
477		dAtA[i] = 0
478	}
479	i++
480	return i, nil
481}
482
483func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
484	size := m.Size()
485	dAtA = make([]byte, size)
486	n, err := m.MarshalTo(dAtA)
487	if err != nil {
488		return nil, err
489	}
490	return dAtA[:n], nil
491}
492
493func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
494	var i int
495	_ = i
496	var l int
497	_ = l
498	dAtA[i] = 0xa
499	i++
500	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
501	n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
502	if err != nil {
503		return 0, err
504	}
505	i += n1
506	dAtA[i] = 0x12
507	i++
508	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
509	n2, err := m.Spec.MarshalTo(dAtA[i:])
510	if err != nil {
511		return 0, err
512	}
513	i += n2
514	dAtA[i] = 0x1a
515	i++
516	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
517	n3, err := m.Status.MarshalTo(dAtA[i:])
518	if err != nil {
519		return 0, err
520	}
521	i += n3
522	return i, nil
523}
524
525func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
526	size := m.Size()
527	dAtA = make([]byte, size)
528	n, err := m.MarshalTo(dAtA)
529	if err != nil {
530		return nil, err
531	}
532	return dAtA[:n], nil
533}
534
535func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
536	var i int
537	_ = i
538	var l int
539	_ = l
540	dAtA[i] = 0xa
541	i++
542	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
543	i += copy(dAtA[i:], m.Type)
544	dAtA[i] = 0x12
545	i++
546	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
547	i += copy(dAtA[i:], m.Status)
548	dAtA[i] = 0x1a
549	i++
550	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
551	n4, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
552	if err != nil {
553		return 0, err
554	}
555	i += n4
556	dAtA[i] = 0x22
557	i++
558	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
559	i += copy(dAtA[i:], m.Reason)
560	dAtA[i] = 0x2a
561	i++
562	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
563	i += copy(dAtA[i:], m.Message)
564	return i, nil
565}
566
567func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
568	size := m.Size()
569	dAtA = make([]byte, size)
570	n, err := m.MarshalTo(dAtA)
571	if err != nil {
572		return nil, err
573	}
574	return dAtA[:n], nil
575}
576
577func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
578	var i int
579	_ = i
580	var l int
581	_ = l
582	dAtA[i] = 0xa
583	i++
584	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
585	n5, err := m.ListMeta.MarshalTo(dAtA[i:])
586	if err != nil {
587		return 0, err
588	}
589	i += n5
590	if len(m.Items) > 0 {
591		for _, msg := range m.Items {
592			dAtA[i] = 0x12
593			i++
594			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
595			n, err := msg.MarshalTo(dAtA[i:])
596			if err != nil {
597				return 0, err
598			}
599			i += n
600		}
601	}
602	return i, nil
603}
604
605func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
606	size := m.Size()
607	dAtA = make([]byte, size)
608	n, err := m.MarshalTo(dAtA)
609	if err != nil {
610		return nil, err
611	}
612	return dAtA[:n], nil
613}
614
615func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
616	var i int
617	_ = i
618	var l int
619	_ = l
620	if m.Selector != nil {
621		dAtA[i] = 0xa
622		i++
623		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
624		n6, err := m.Selector.MarshalTo(dAtA[i:])
625		if err != nil {
626			return 0, err
627		}
628		i += n6
629	}
630	dAtA[i] = 0x12
631	i++
632	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
633	n7, err := m.Template.MarshalTo(dAtA[i:])
634	if err != nil {
635		return 0, err
636	}
637	i += n7
638	dAtA[i] = 0x1a
639	i++
640	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
641	n8, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
642	if err != nil {
643		return 0, err
644	}
645	i += n8
646	dAtA[i] = 0x20
647	i++
648	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
649	dAtA[i] = 0x28
650	i++
651	i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration))
652	if m.RevisionHistoryLimit != nil {
653		dAtA[i] = 0x30
654		i++
655		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
656	}
657	return i, nil
658}
659
660func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
661	size := m.Size()
662	dAtA = make([]byte, size)
663	n, err := m.MarshalTo(dAtA)
664	if err != nil {
665		return nil, err
666	}
667	return dAtA[:n], nil
668}
669
670func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
671	var i int
672	_ = i
673	var l int
674	_ = l
675	dAtA[i] = 0x8
676	i++
677	i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
678	dAtA[i] = 0x10
679	i++
680	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
681	dAtA[i] = 0x18
682	i++
683	i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
684	dAtA[i] = 0x20
685	i++
686	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
687	dAtA[i] = 0x28
688	i++
689	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
690	dAtA[i] = 0x30
691	i++
692	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
693	dAtA[i] = 0x38
694	i++
695	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
696	dAtA[i] = 0x40
697	i++
698	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
699	if m.CollisionCount != nil {
700		dAtA[i] = 0x48
701		i++
702		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
703	}
704	if len(m.Conditions) > 0 {
705		for _, msg := range m.Conditions {
706			dAtA[i] = 0x52
707			i++
708			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
709			n, err := msg.MarshalTo(dAtA[i:])
710			if err != nil {
711				return 0, err
712			}
713			i += n
714		}
715	}
716	return i, nil
717}
718
719func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
720	size := m.Size()
721	dAtA = make([]byte, size)
722	n, err := m.MarshalTo(dAtA)
723	if err != nil {
724		return nil, err
725	}
726	return dAtA[:n], nil
727}
728
729func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
730	var i int
731	_ = i
732	var l int
733	_ = l
734	dAtA[i] = 0xa
735	i++
736	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
737	i += copy(dAtA[i:], m.Type)
738	if m.RollingUpdate != nil {
739		dAtA[i] = 0x12
740		i++
741		i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
742		n9, err := m.RollingUpdate.MarshalTo(dAtA[i:])
743		if err != nil {
744			return 0, err
745		}
746		i += n9
747	}
748	return i, nil
749}
750
751func (m *Deployment) Marshal() (dAtA []byte, err error) {
752	size := m.Size()
753	dAtA = make([]byte, size)
754	n, err := m.MarshalTo(dAtA)
755	if err != nil {
756		return nil, err
757	}
758	return dAtA[:n], nil
759}
760
761func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
762	var i int
763	_ = i
764	var l int
765	_ = l
766	dAtA[i] = 0xa
767	i++
768	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
769	n10, err := m.ObjectMeta.MarshalTo(dAtA[i:])
770	if err != nil {
771		return 0, err
772	}
773	i += n10
774	dAtA[i] = 0x12
775	i++
776	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
777	n11, err := m.Spec.MarshalTo(dAtA[i:])
778	if err != nil {
779		return 0, err
780	}
781	i += n11
782	dAtA[i] = 0x1a
783	i++
784	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
785	n12, err := m.Status.MarshalTo(dAtA[i:])
786	if err != nil {
787		return 0, err
788	}
789	i += n12
790	return i, nil
791}
792
793func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
794	size := m.Size()
795	dAtA = make([]byte, size)
796	n, err := m.MarshalTo(dAtA)
797	if err != nil {
798		return nil, err
799	}
800	return dAtA[:n], nil
801}
802
803func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
804	var i int
805	_ = i
806	var l int
807	_ = l
808	dAtA[i] = 0xa
809	i++
810	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
811	i += copy(dAtA[i:], m.Type)
812	dAtA[i] = 0x12
813	i++
814	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
815	i += copy(dAtA[i:], m.Status)
816	dAtA[i] = 0x22
817	i++
818	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
819	i += copy(dAtA[i:], m.Reason)
820	dAtA[i] = 0x2a
821	i++
822	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
823	i += copy(dAtA[i:], m.Message)
824	dAtA[i] = 0x32
825	i++
826	i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
827	n13, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
828	if err != nil {
829		return 0, err
830	}
831	i += n13
832	dAtA[i] = 0x3a
833	i++
834	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
835	n14, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
836	if err != nil {
837		return 0, err
838	}
839	i += n14
840	return i, nil
841}
842
843func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
844	size := m.Size()
845	dAtA = make([]byte, size)
846	n, err := m.MarshalTo(dAtA)
847	if err != nil {
848		return nil, err
849	}
850	return dAtA[:n], nil
851}
852
853func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
854	var i int
855	_ = i
856	var l int
857	_ = l
858	dAtA[i] = 0xa
859	i++
860	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
861	n15, err := m.ListMeta.MarshalTo(dAtA[i:])
862	if err != nil {
863		return 0, err
864	}
865	i += n15
866	if len(m.Items) > 0 {
867		for _, msg := range m.Items {
868			dAtA[i] = 0x12
869			i++
870			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
871			n, err := msg.MarshalTo(dAtA[i:])
872			if err != nil {
873				return 0, err
874			}
875			i += n
876		}
877	}
878	return i, nil
879}
880
881func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
882	size := m.Size()
883	dAtA = make([]byte, size)
884	n, err := m.MarshalTo(dAtA)
885	if err != nil {
886		return nil, err
887	}
888	return dAtA[:n], nil
889}
890
891func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
892	var i int
893	_ = i
894	var l int
895	_ = l
896	dAtA[i] = 0xa
897	i++
898	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
899	i += copy(dAtA[i:], m.Name)
900	if len(m.UpdatedAnnotations) > 0 {
901		keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
902		for k := range m.UpdatedAnnotations {
903			keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
904		}
905		github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
906		for _, k := range keysForUpdatedAnnotations {
907			dAtA[i] = 0x12
908			i++
909			v := m.UpdatedAnnotations[string(k)]
910			mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
911			i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
912			dAtA[i] = 0xa
913			i++
914			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
915			i += copy(dAtA[i:], k)
916			dAtA[i] = 0x12
917			i++
918			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
919			i += copy(dAtA[i:], v)
920		}
921	}
922	dAtA[i] = 0x1a
923	i++
924	i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
925	n16, err := m.RollbackTo.MarshalTo(dAtA[i:])
926	if err != nil {
927		return 0, err
928	}
929	i += n16
930	return i, nil
931}
932
933func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
934	size := m.Size()
935	dAtA = make([]byte, size)
936	n, err := m.MarshalTo(dAtA)
937	if err != nil {
938		return nil, err
939	}
940	return dAtA[:n], nil
941}
942
943func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
944	var i int
945	_ = i
946	var l int
947	_ = l
948	if m.Replicas != nil {
949		dAtA[i] = 0x8
950		i++
951		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
952	}
953	if m.Selector != nil {
954		dAtA[i] = 0x12
955		i++
956		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
957		n17, err := m.Selector.MarshalTo(dAtA[i:])
958		if err != nil {
959			return 0, err
960		}
961		i += n17
962	}
963	dAtA[i] = 0x1a
964	i++
965	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
966	n18, err := m.Template.MarshalTo(dAtA[i:])
967	if err != nil {
968		return 0, err
969	}
970	i += n18
971	dAtA[i] = 0x22
972	i++
973	i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size()))
974	n19, err := m.Strategy.MarshalTo(dAtA[i:])
975	if err != nil {
976		return 0, err
977	}
978	i += n19
979	dAtA[i] = 0x28
980	i++
981	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
982	if m.RevisionHistoryLimit != nil {
983		dAtA[i] = 0x30
984		i++
985		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
986	}
987	dAtA[i] = 0x38
988	i++
989	if m.Paused {
990		dAtA[i] = 1
991	} else {
992		dAtA[i] = 0
993	}
994	i++
995	if m.RollbackTo != nil {
996		dAtA[i] = 0x42
997		i++
998		i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size()))
999		n20, err := m.RollbackTo.MarshalTo(dAtA[i:])
1000		if err != nil {
1001			return 0, err
1002		}
1003		i += n20
1004	}
1005	if m.ProgressDeadlineSeconds != nil {
1006		dAtA[i] = 0x48
1007		i++
1008		i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
1009	}
1010	return i, nil
1011}
1012
1013func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
1014	size := m.Size()
1015	dAtA = make([]byte, size)
1016	n, err := m.MarshalTo(dAtA)
1017	if err != nil {
1018		return nil, err
1019	}
1020	return dAtA[:n], nil
1021}
1022
1023func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
1024	var i int
1025	_ = i
1026	var l int
1027	_ = l
1028	dAtA[i] = 0x8
1029	i++
1030	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1031	dAtA[i] = 0x10
1032	i++
1033	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1034	dAtA[i] = 0x18
1035	i++
1036	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1037	dAtA[i] = 0x20
1038	i++
1039	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1040	dAtA[i] = 0x28
1041	i++
1042	i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
1043	if len(m.Conditions) > 0 {
1044		for _, msg := range m.Conditions {
1045			dAtA[i] = 0x32
1046			i++
1047			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1048			n, err := msg.MarshalTo(dAtA[i:])
1049			if err != nil {
1050				return 0, err
1051			}
1052			i += n
1053		}
1054	}
1055	dAtA[i] = 0x38
1056	i++
1057	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1058	if m.CollisionCount != nil {
1059		dAtA[i] = 0x40
1060		i++
1061		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1062	}
1063	return i, nil
1064}
1065
1066func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
1067	size := m.Size()
1068	dAtA = make([]byte, size)
1069	n, err := m.MarshalTo(dAtA)
1070	if err != nil {
1071		return nil, err
1072	}
1073	return dAtA[:n], nil
1074}
1075
1076func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
1077	var i int
1078	_ = i
1079	var l int
1080	_ = l
1081	dAtA[i] = 0xa
1082	i++
1083	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1084	i += copy(dAtA[i:], m.Type)
1085	if m.RollingUpdate != nil {
1086		dAtA[i] = 0x12
1087		i++
1088		i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
1089		n21, err := m.RollingUpdate.MarshalTo(dAtA[i:])
1090		if err != nil {
1091			return 0, err
1092		}
1093		i += n21
1094	}
1095	return i, nil
1096}
1097
1098func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
1099	size := m.Size()
1100	dAtA = make([]byte, size)
1101	n, err := m.MarshalTo(dAtA)
1102	if err != nil {
1103		return nil, err
1104	}
1105	return dAtA[:n], nil
1106}
1107
1108func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
1109	var i int
1110	_ = i
1111	var l int
1112	_ = l
1113	dAtA[i] = 0xa
1114	i++
1115	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
1116	i += copy(dAtA[i:], m.Rule)
1117	if len(m.Ranges) > 0 {
1118		for _, msg := range m.Ranges {
1119			dAtA[i] = 0x12
1120			i++
1121			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1122			n, err := msg.MarshalTo(dAtA[i:])
1123			if err != nil {
1124				return 0, err
1125			}
1126			i += n
1127		}
1128	}
1129	return i, nil
1130}
1131
1132func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) {
1133	size := m.Size()
1134	dAtA = make([]byte, size)
1135	n, err := m.MarshalTo(dAtA)
1136	if err != nil {
1137		return nil, err
1138	}
1139	return dAtA[:n], nil
1140}
1141
1142func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) {
1143	var i int
1144	_ = i
1145	var l int
1146	_ = l
1147	dAtA[i] = 0xa
1148	i++
1149	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
1150	i += copy(dAtA[i:], m.Path)
1151	dAtA[i] = 0x12
1152	i++
1153	i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1154	n22, err := m.Backend.MarshalTo(dAtA[i:])
1155	if err != nil {
1156		return 0, err
1157	}
1158	i += n22
1159	return i, nil
1160}
1161
1162func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) {
1163	size := m.Size()
1164	dAtA = make([]byte, size)
1165	n, err := m.MarshalTo(dAtA)
1166	if err != nil {
1167		return nil, err
1168	}
1169	return dAtA[:n], nil
1170}
1171
1172func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1173	var i int
1174	_ = i
1175	var l int
1176	_ = l
1177	if len(m.Paths) > 0 {
1178		for _, msg := range m.Paths {
1179			dAtA[i] = 0xa
1180			i++
1181			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1182			n, err := msg.MarshalTo(dAtA[i:])
1183			if err != nil {
1184				return 0, err
1185			}
1186			i += n
1187		}
1188	}
1189	return i, nil
1190}
1191
1192func (m *HostPortRange) Marshal() (dAtA []byte, err error) {
1193	size := m.Size()
1194	dAtA = make([]byte, size)
1195	n, err := m.MarshalTo(dAtA)
1196	if err != nil {
1197		return nil, err
1198	}
1199	return dAtA[:n], nil
1200}
1201
1202func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) {
1203	var i int
1204	_ = i
1205	var l int
1206	_ = l
1207	dAtA[i] = 0x8
1208	i++
1209	i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1210	dAtA[i] = 0x10
1211	i++
1212	i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1213	return i, nil
1214}
1215
1216func (m *IDRange) Marshal() (dAtA []byte, err error) {
1217	size := m.Size()
1218	dAtA = make([]byte, size)
1219	n, err := m.MarshalTo(dAtA)
1220	if err != nil {
1221		return nil, err
1222	}
1223	return dAtA[:n], nil
1224}
1225
1226func (m *IDRange) MarshalTo(dAtA []byte) (int, error) {
1227	var i int
1228	_ = i
1229	var l int
1230	_ = l
1231	dAtA[i] = 0x8
1232	i++
1233	i = encodeVarintGenerated(dAtA, i, uint64(m.Min))
1234	dAtA[i] = 0x10
1235	i++
1236	i = encodeVarintGenerated(dAtA, i, uint64(m.Max))
1237	return i, nil
1238}
1239
1240func (m *IPBlock) Marshal() (dAtA []byte, err error) {
1241	size := m.Size()
1242	dAtA = make([]byte, size)
1243	n, err := m.MarshalTo(dAtA)
1244	if err != nil {
1245		return nil, err
1246	}
1247	return dAtA[:n], nil
1248}
1249
1250func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) {
1251	var i int
1252	_ = i
1253	var l int
1254	_ = l
1255	dAtA[i] = 0xa
1256	i++
1257	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR)))
1258	i += copy(dAtA[i:], m.CIDR)
1259	if len(m.Except) > 0 {
1260		for _, s := range m.Except {
1261			dAtA[i] = 0x12
1262			i++
1263			l = len(s)
1264			for l >= 1<<7 {
1265				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1266				l >>= 7
1267				i++
1268			}
1269			dAtA[i] = uint8(l)
1270			i++
1271			i += copy(dAtA[i:], s)
1272		}
1273	}
1274	return i, nil
1275}
1276
1277func (m *Ingress) Marshal() (dAtA []byte, err error) {
1278	size := m.Size()
1279	dAtA = make([]byte, size)
1280	n, err := m.MarshalTo(dAtA)
1281	if err != nil {
1282		return nil, err
1283	}
1284	return dAtA[:n], nil
1285}
1286
1287func (m *Ingress) MarshalTo(dAtA []byte) (int, error) {
1288	var i int
1289	_ = i
1290	var l int
1291	_ = l
1292	dAtA[i] = 0xa
1293	i++
1294	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1295	n23, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1296	if err != nil {
1297		return 0, err
1298	}
1299	i += n23
1300	dAtA[i] = 0x12
1301	i++
1302	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1303	n24, err := m.Spec.MarshalTo(dAtA[i:])
1304	if err != nil {
1305		return 0, err
1306	}
1307	i += n24
1308	dAtA[i] = 0x1a
1309	i++
1310	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
1311	n25, err := m.Status.MarshalTo(dAtA[i:])
1312	if err != nil {
1313		return 0, err
1314	}
1315	i += n25
1316	return i, nil
1317}
1318
1319func (m *IngressBackend) Marshal() (dAtA []byte, err error) {
1320	size := m.Size()
1321	dAtA = make([]byte, size)
1322	n, err := m.MarshalTo(dAtA)
1323	if err != nil {
1324		return nil, err
1325	}
1326	return dAtA[:n], nil
1327}
1328
1329func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) {
1330	var i int
1331	_ = i
1332	var l int
1333	_ = l
1334	dAtA[i] = 0xa
1335	i++
1336	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
1337	i += copy(dAtA[i:], m.ServiceName)
1338	dAtA[i] = 0x12
1339	i++
1340	i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort.Size()))
1341	n26, err := m.ServicePort.MarshalTo(dAtA[i:])
1342	if err != nil {
1343		return 0, err
1344	}
1345	i += n26
1346	return i, nil
1347}
1348
1349func (m *IngressList) Marshal() (dAtA []byte, err error) {
1350	size := m.Size()
1351	dAtA = make([]byte, size)
1352	n, err := m.MarshalTo(dAtA)
1353	if err != nil {
1354		return nil, err
1355	}
1356	return dAtA[:n], nil
1357}
1358
1359func (m *IngressList) MarshalTo(dAtA []byte) (int, error) {
1360	var i int
1361	_ = i
1362	var l int
1363	_ = l
1364	dAtA[i] = 0xa
1365	i++
1366	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1367	n27, err := m.ListMeta.MarshalTo(dAtA[i:])
1368	if err != nil {
1369		return 0, err
1370	}
1371	i += n27
1372	if len(m.Items) > 0 {
1373		for _, msg := range m.Items {
1374			dAtA[i] = 0x12
1375			i++
1376			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1377			n, err := msg.MarshalTo(dAtA[i:])
1378			if err != nil {
1379				return 0, err
1380			}
1381			i += n
1382		}
1383	}
1384	return i, nil
1385}
1386
1387func (m *IngressRule) Marshal() (dAtA []byte, err error) {
1388	size := m.Size()
1389	dAtA = make([]byte, size)
1390	n, err := m.MarshalTo(dAtA)
1391	if err != nil {
1392		return nil, err
1393	}
1394	return dAtA[:n], nil
1395}
1396
1397func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) {
1398	var i int
1399	_ = i
1400	var l int
1401	_ = l
1402	dAtA[i] = 0xa
1403	i++
1404	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
1405	i += copy(dAtA[i:], m.Host)
1406	dAtA[i] = 0x12
1407	i++
1408	i = encodeVarintGenerated(dAtA, i, uint64(m.IngressRuleValue.Size()))
1409	n28, err := m.IngressRuleValue.MarshalTo(dAtA[i:])
1410	if err != nil {
1411		return 0, err
1412	}
1413	i += n28
1414	return i, nil
1415}
1416
1417func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) {
1418	size := m.Size()
1419	dAtA = make([]byte, size)
1420	n, err := m.MarshalTo(dAtA)
1421	if err != nil {
1422		return nil, err
1423	}
1424	return dAtA[:n], nil
1425}
1426
1427func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
1428	var i int
1429	_ = i
1430	var l int
1431	_ = l
1432	if m.HTTP != nil {
1433		dAtA[i] = 0xa
1434		i++
1435		i = encodeVarintGenerated(dAtA, i, uint64(m.HTTP.Size()))
1436		n29, err := m.HTTP.MarshalTo(dAtA[i:])
1437		if err != nil {
1438			return 0, err
1439		}
1440		i += n29
1441	}
1442	return i, nil
1443}
1444
1445func (m *IngressSpec) Marshal() (dAtA []byte, err error) {
1446	size := m.Size()
1447	dAtA = make([]byte, size)
1448	n, err := m.MarshalTo(dAtA)
1449	if err != nil {
1450		return nil, err
1451	}
1452	return dAtA[:n], nil
1453}
1454
1455func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) {
1456	var i int
1457	_ = i
1458	var l int
1459	_ = l
1460	if m.Backend != nil {
1461		dAtA[i] = 0xa
1462		i++
1463		i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size()))
1464		n30, err := m.Backend.MarshalTo(dAtA[i:])
1465		if err != nil {
1466			return 0, err
1467		}
1468		i += n30
1469	}
1470	if len(m.TLS) > 0 {
1471		for _, msg := range m.TLS {
1472			dAtA[i] = 0x12
1473			i++
1474			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1475			n, err := msg.MarshalTo(dAtA[i:])
1476			if err != nil {
1477				return 0, err
1478			}
1479			i += n
1480		}
1481	}
1482	if len(m.Rules) > 0 {
1483		for _, msg := range m.Rules {
1484			dAtA[i] = 0x1a
1485			i++
1486			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1487			n, err := msg.MarshalTo(dAtA[i:])
1488			if err != nil {
1489				return 0, err
1490			}
1491			i += n
1492		}
1493	}
1494	return i, nil
1495}
1496
1497func (m *IngressStatus) Marshal() (dAtA []byte, err error) {
1498	size := m.Size()
1499	dAtA = make([]byte, size)
1500	n, err := m.MarshalTo(dAtA)
1501	if err != nil {
1502		return nil, err
1503	}
1504	return dAtA[:n], nil
1505}
1506
1507func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) {
1508	var i int
1509	_ = i
1510	var l int
1511	_ = l
1512	dAtA[i] = 0xa
1513	i++
1514	i = encodeVarintGenerated(dAtA, i, uint64(m.LoadBalancer.Size()))
1515	n31, err := m.LoadBalancer.MarshalTo(dAtA[i:])
1516	if err != nil {
1517		return 0, err
1518	}
1519	i += n31
1520	return i, nil
1521}
1522
1523func (m *IngressTLS) Marshal() (dAtA []byte, err error) {
1524	size := m.Size()
1525	dAtA = make([]byte, size)
1526	n, err := m.MarshalTo(dAtA)
1527	if err != nil {
1528		return nil, err
1529	}
1530	return dAtA[:n], nil
1531}
1532
1533func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) {
1534	var i int
1535	_ = i
1536	var l int
1537	_ = l
1538	if len(m.Hosts) > 0 {
1539		for _, s := range m.Hosts {
1540			dAtA[i] = 0xa
1541			i++
1542			l = len(s)
1543			for l >= 1<<7 {
1544				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1545				l >>= 7
1546				i++
1547			}
1548			dAtA[i] = uint8(l)
1549			i++
1550			i += copy(dAtA[i:], s)
1551		}
1552	}
1553	dAtA[i] = 0x12
1554	i++
1555	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName)))
1556	i += copy(dAtA[i:], m.SecretName)
1557	return i, nil
1558}
1559
1560func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) {
1561	size := m.Size()
1562	dAtA = make([]byte, size)
1563	n, err := m.MarshalTo(dAtA)
1564	if err != nil {
1565		return nil, err
1566	}
1567	return dAtA[:n], nil
1568}
1569
1570func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) {
1571	var i int
1572	_ = i
1573	var l int
1574	_ = l
1575	dAtA[i] = 0xa
1576	i++
1577	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1578	n32, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1579	if err != nil {
1580		return 0, err
1581	}
1582	i += n32
1583	dAtA[i] = 0x12
1584	i++
1585	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1586	n33, err := m.Spec.MarshalTo(dAtA[i:])
1587	if err != nil {
1588		return 0, err
1589	}
1590	i += n33
1591	return i, nil
1592}
1593
1594func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) {
1595	size := m.Size()
1596	dAtA = make([]byte, size)
1597	n, err := m.MarshalTo(dAtA)
1598	if err != nil {
1599		return nil, err
1600	}
1601	return dAtA[:n], nil
1602}
1603
1604func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) {
1605	var i int
1606	_ = i
1607	var l int
1608	_ = l
1609	if len(m.Ports) > 0 {
1610		for _, msg := range m.Ports {
1611			dAtA[i] = 0xa
1612			i++
1613			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1614			n, err := msg.MarshalTo(dAtA[i:])
1615			if err != nil {
1616				return 0, err
1617			}
1618			i += n
1619		}
1620	}
1621	if len(m.To) > 0 {
1622		for _, msg := range m.To {
1623			dAtA[i] = 0x12
1624			i++
1625			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1626			n, err := msg.MarshalTo(dAtA[i:])
1627			if err != nil {
1628				return 0, err
1629			}
1630			i += n
1631		}
1632	}
1633	return i, nil
1634}
1635
1636func (m *NetworkPolicyIngressRule) Marshal() (dAtA []byte, err error) {
1637	size := m.Size()
1638	dAtA = make([]byte, size)
1639	n, err := m.MarshalTo(dAtA)
1640	if err != nil {
1641		return nil, err
1642	}
1643	return dAtA[:n], nil
1644}
1645
1646func (m *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) {
1647	var i int
1648	_ = i
1649	var l int
1650	_ = l
1651	if len(m.Ports) > 0 {
1652		for _, msg := range m.Ports {
1653			dAtA[i] = 0xa
1654			i++
1655			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1656			n, err := msg.MarshalTo(dAtA[i:])
1657			if err != nil {
1658				return 0, err
1659			}
1660			i += n
1661		}
1662	}
1663	if len(m.From) > 0 {
1664		for _, msg := range m.From {
1665			dAtA[i] = 0x12
1666			i++
1667			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1668			n, err := msg.MarshalTo(dAtA[i:])
1669			if err != nil {
1670				return 0, err
1671			}
1672			i += n
1673		}
1674	}
1675	return i, nil
1676}
1677
1678func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) {
1679	size := m.Size()
1680	dAtA = make([]byte, size)
1681	n, err := m.MarshalTo(dAtA)
1682	if err != nil {
1683		return nil, err
1684	}
1685	return dAtA[:n], nil
1686}
1687
1688func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) {
1689	var i int
1690	_ = i
1691	var l int
1692	_ = l
1693	dAtA[i] = 0xa
1694	i++
1695	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1696	n34, err := m.ListMeta.MarshalTo(dAtA[i:])
1697	if err != nil {
1698		return 0, err
1699	}
1700	i += n34
1701	if len(m.Items) > 0 {
1702		for _, msg := range m.Items {
1703			dAtA[i] = 0x12
1704			i++
1705			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1706			n, err := msg.MarshalTo(dAtA[i:])
1707			if err != nil {
1708				return 0, err
1709			}
1710			i += n
1711		}
1712	}
1713	return i, nil
1714}
1715
1716func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) {
1717	size := m.Size()
1718	dAtA = make([]byte, size)
1719	n, err := m.MarshalTo(dAtA)
1720	if err != nil {
1721		return nil, err
1722	}
1723	return dAtA[:n], nil
1724}
1725
1726func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) {
1727	var i int
1728	_ = i
1729	var l int
1730	_ = l
1731	if m.PodSelector != nil {
1732		dAtA[i] = 0xa
1733		i++
1734		i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1735		n35, err := m.PodSelector.MarshalTo(dAtA[i:])
1736		if err != nil {
1737			return 0, err
1738		}
1739		i += n35
1740	}
1741	if m.NamespaceSelector != nil {
1742		dAtA[i] = 0x12
1743		i++
1744		i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
1745		n36, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
1746		if err != nil {
1747			return 0, err
1748		}
1749		i += n36
1750	}
1751	if m.IPBlock != nil {
1752		dAtA[i] = 0x1a
1753		i++
1754		i = encodeVarintGenerated(dAtA, i, uint64(m.IPBlock.Size()))
1755		n37, err := m.IPBlock.MarshalTo(dAtA[i:])
1756		if err != nil {
1757			return 0, err
1758		}
1759		i += n37
1760	}
1761	return i, nil
1762}
1763
1764func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) {
1765	size := m.Size()
1766	dAtA = make([]byte, size)
1767	n, err := m.MarshalTo(dAtA)
1768	if err != nil {
1769		return nil, err
1770	}
1771	return dAtA[:n], nil
1772}
1773
1774func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) {
1775	var i int
1776	_ = i
1777	var l int
1778	_ = l
1779	if m.Protocol != nil {
1780		dAtA[i] = 0xa
1781		i++
1782		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol)))
1783		i += copy(dAtA[i:], *m.Protocol)
1784	}
1785	if m.Port != nil {
1786		dAtA[i] = 0x12
1787		i++
1788		i = encodeVarintGenerated(dAtA, i, uint64(m.Port.Size()))
1789		n38, err := m.Port.MarshalTo(dAtA[i:])
1790		if err != nil {
1791			return 0, err
1792		}
1793		i += n38
1794	}
1795	return i, nil
1796}
1797
1798func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) {
1799	size := m.Size()
1800	dAtA = make([]byte, size)
1801	n, err := m.MarshalTo(dAtA)
1802	if err != nil {
1803		return nil, err
1804	}
1805	return dAtA[:n], nil
1806}
1807
1808func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1809	var i int
1810	_ = i
1811	var l int
1812	_ = l
1813	dAtA[i] = 0xa
1814	i++
1815	i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size()))
1816	n39, err := m.PodSelector.MarshalTo(dAtA[i:])
1817	if err != nil {
1818		return 0, err
1819	}
1820	i += n39
1821	if len(m.Ingress) > 0 {
1822		for _, msg := range m.Ingress {
1823			dAtA[i] = 0x12
1824			i++
1825			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1826			n, err := msg.MarshalTo(dAtA[i:])
1827			if err != nil {
1828				return 0, err
1829			}
1830			i += n
1831		}
1832	}
1833	if len(m.Egress) > 0 {
1834		for _, msg := range m.Egress {
1835			dAtA[i] = 0x1a
1836			i++
1837			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1838			n, err := msg.MarshalTo(dAtA[i:])
1839			if err != nil {
1840				return 0, err
1841			}
1842			i += n
1843		}
1844	}
1845	if len(m.PolicyTypes) > 0 {
1846		for _, s := range m.PolicyTypes {
1847			dAtA[i] = 0x22
1848			i++
1849			l = len(s)
1850			for l >= 1<<7 {
1851				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1852				l >>= 7
1853				i++
1854			}
1855			dAtA[i] = uint8(l)
1856			i++
1857			i += copy(dAtA[i:], s)
1858		}
1859	}
1860	return i, nil
1861}
1862
1863func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) {
1864	size := m.Size()
1865	dAtA = make([]byte, size)
1866	n, err := m.MarshalTo(dAtA)
1867	if err != nil {
1868		return nil, err
1869	}
1870	return dAtA[:n], nil
1871}
1872
1873func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) {
1874	var i int
1875	_ = i
1876	var l int
1877	_ = l
1878	dAtA[i] = 0xa
1879	i++
1880	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1881	n40, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1882	if err != nil {
1883		return 0, err
1884	}
1885	i += n40
1886	dAtA[i] = 0x12
1887	i++
1888	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1889	n41, err := m.Spec.MarshalTo(dAtA[i:])
1890	if err != nil {
1891		return 0, err
1892	}
1893	i += n41
1894	return i, nil
1895}
1896
1897func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) {
1898	size := m.Size()
1899	dAtA = make([]byte, size)
1900	n, err := m.MarshalTo(dAtA)
1901	if err != nil {
1902		return nil, err
1903	}
1904	return dAtA[:n], nil
1905}
1906
1907func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) {
1908	var i int
1909	_ = i
1910	var l int
1911	_ = l
1912	dAtA[i] = 0xa
1913	i++
1914	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1915	n42, err := m.ListMeta.MarshalTo(dAtA[i:])
1916	if err != nil {
1917		return 0, err
1918	}
1919	i += n42
1920	if len(m.Items) > 0 {
1921		for _, msg := range m.Items {
1922			dAtA[i] = 0x12
1923			i++
1924			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1925			n, err := msg.MarshalTo(dAtA[i:])
1926			if err != nil {
1927				return 0, err
1928			}
1929			i += n
1930		}
1931	}
1932	return i, nil
1933}
1934
1935func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) {
1936	size := m.Size()
1937	dAtA = make([]byte, size)
1938	n, err := m.MarshalTo(dAtA)
1939	if err != nil {
1940		return nil, err
1941	}
1942	return dAtA[:n], nil
1943}
1944
1945func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) {
1946	var i int
1947	_ = i
1948	var l int
1949	_ = l
1950	dAtA[i] = 0x8
1951	i++
1952	if m.Privileged {
1953		dAtA[i] = 1
1954	} else {
1955		dAtA[i] = 0
1956	}
1957	i++
1958	if len(m.DefaultAddCapabilities) > 0 {
1959		for _, s := range m.DefaultAddCapabilities {
1960			dAtA[i] = 0x12
1961			i++
1962			l = len(s)
1963			for l >= 1<<7 {
1964				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1965				l >>= 7
1966				i++
1967			}
1968			dAtA[i] = uint8(l)
1969			i++
1970			i += copy(dAtA[i:], s)
1971		}
1972	}
1973	if len(m.RequiredDropCapabilities) > 0 {
1974		for _, s := range m.RequiredDropCapabilities {
1975			dAtA[i] = 0x1a
1976			i++
1977			l = len(s)
1978			for l >= 1<<7 {
1979				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1980				l >>= 7
1981				i++
1982			}
1983			dAtA[i] = uint8(l)
1984			i++
1985			i += copy(dAtA[i:], s)
1986		}
1987	}
1988	if len(m.AllowedCapabilities) > 0 {
1989		for _, s := range m.AllowedCapabilities {
1990			dAtA[i] = 0x22
1991			i++
1992			l = len(s)
1993			for l >= 1<<7 {
1994				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1995				l >>= 7
1996				i++
1997			}
1998			dAtA[i] = uint8(l)
1999			i++
2000			i += copy(dAtA[i:], s)
2001		}
2002	}
2003	if len(m.Volumes) > 0 {
2004		for _, s := range m.Volumes {
2005			dAtA[i] = 0x2a
2006			i++
2007			l = len(s)
2008			for l >= 1<<7 {
2009				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2010				l >>= 7
2011				i++
2012			}
2013			dAtA[i] = uint8(l)
2014			i++
2015			i += copy(dAtA[i:], s)
2016		}
2017	}
2018	dAtA[i] = 0x30
2019	i++
2020	if m.HostNetwork {
2021		dAtA[i] = 1
2022	} else {
2023		dAtA[i] = 0
2024	}
2025	i++
2026	if len(m.HostPorts) > 0 {
2027		for _, msg := range m.HostPorts {
2028			dAtA[i] = 0x3a
2029			i++
2030			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2031			n, err := msg.MarshalTo(dAtA[i:])
2032			if err != nil {
2033				return 0, err
2034			}
2035			i += n
2036		}
2037	}
2038	dAtA[i] = 0x40
2039	i++
2040	if m.HostPID {
2041		dAtA[i] = 1
2042	} else {
2043		dAtA[i] = 0
2044	}
2045	i++
2046	dAtA[i] = 0x48
2047	i++
2048	if m.HostIPC {
2049		dAtA[i] = 1
2050	} else {
2051		dAtA[i] = 0
2052	}
2053	i++
2054	dAtA[i] = 0x52
2055	i++
2056	i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size()))
2057	n43, err := m.SELinux.MarshalTo(dAtA[i:])
2058	if err != nil {
2059		return 0, err
2060	}
2061	i += n43
2062	dAtA[i] = 0x5a
2063	i++
2064	i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size()))
2065	n44, err := m.RunAsUser.MarshalTo(dAtA[i:])
2066	if err != nil {
2067		return 0, err
2068	}
2069	i += n44
2070	dAtA[i] = 0x62
2071	i++
2072	i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size()))
2073	n45, err := m.SupplementalGroups.MarshalTo(dAtA[i:])
2074	if err != nil {
2075		return 0, err
2076	}
2077	i += n45
2078	dAtA[i] = 0x6a
2079	i++
2080	i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size()))
2081	n46, err := m.FSGroup.MarshalTo(dAtA[i:])
2082	if err != nil {
2083		return 0, err
2084	}
2085	i += n46
2086	dAtA[i] = 0x70
2087	i++
2088	if m.ReadOnlyRootFilesystem {
2089		dAtA[i] = 1
2090	} else {
2091		dAtA[i] = 0
2092	}
2093	i++
2094	if m.DefaultAllowPrivilegeEscalation != nil {
2095		dAtA[i] = 0x78
2096		i++
2097		if *m.DefaultAllowPrivilegeEscalation {
2098			dAtA[i] = 1
2099		} else {
2100			dAtA[i] = 0
2101		}
2102		i++
2103	}
2104	if m.AllowPrivilegeEscalation != nil {
2105		dAtA[i] = 0x80
2106		i++
2107		dAtA[i] = 0x1
2108		i++
2109		if *m.AllowPrivilegeEscalation {
2110			dAtA[i] = 1
2111		} else {
2112			dAtA[i] = 0
2113		}
2114		i++
2115	}
2116	if len(m.AllowedHostPaths) > 0 {
2117		for _, msg := range m.AllowedHostPaths {
2118			dAtA[i] = 0x8a
2119			i++
2120			dAtA[i] = 0x1
2121			i++
2122			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2123			n, err := msg.MarshalTo(dAtA[i:])
2124			if err != nil {
2125				return 0, err
2126			}
2127			i += n
2128		}
2129	}
2130	if len(m.AllowedFlexVolumes) > 0 {
2131		for _, msg := range m.AllowedFlexVolumes {
2132			dAtA[i] = 0x92
2133			i++
2134			dAtA[i] = 0x1
2135			i++
2136			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2137			n, err := msg.MarshalTo(dAtA[i:])
2138			if err != nil {
2139				return 0, err
2140			}
2141			i += n
2142		}
2143	}
2144	if len(m.AllowedUnsafeSysctls) > 0 {
2145		for _, s := range m.AllowedUnsafeSysctls {
2146			dAtA[i] = 0x9a
2147			i++
2148			dAtA[i] = 0x1
2149			i++
2150			l = len(s)
2151			for l >= 1<<7 {
2152				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2153				l >>= 7
2154				i++
2155			}
2156			dAtA[i] = uint8(l)
2157			i++
2158			i += copy(dAtA[i:], s)
2159		}
2160	}
2161	if len(m.ForbiddenSysctls) > 0 {
2162		for _, s := range m.ForbiddenSysctls {
2163			dAtA[i] = 0xa2
2164			i++
2165			dAtA[i] = 0x1
2166			i++
2167			l = len(s)
2168			for l >= 1<<7 {
2169				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2170				l >>= 7
2171				i++
2172			}
2173			dAtA[i] = uint8(l)
2174			i++
2175			i += copy(dAtA[i:], s)
2176		}
2177	}
2178	if len(m.AllowedProcMountTypes) > 0 {
2179		for _, s := range m.AllowedProcMountTypes {
2180			dAtA[i] = 0xaa
2181			i++
2182			dAtA[i] = 0x1
2183			i++
2184			l = len(s)
2185			for l >= 1<<7 {
2186				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
2187				l >>= 7
2188				i++
2189			}
2190			dAtA[i] = uint8(l)
2191			i++
2192			i += copy(dAtA[i:], s)
2193		}
2194	}
2195	if m.RunAsGroup != nil {
2196		dAtA[i] = 0xb2
2197		i++
2198		dAtA[i] = 0x1
2199		i++
2200		i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size()))
2201		n47, err := m.RunAsGroup.MarshalTo(dAtA[i:])
2202		if err != nil {
2203			return 0, err
2204		}
2205		i += n47
2206	}
2207	if len(m.AllowedCSIDrivers) > 0 {
2208		for _, msg := range m.AllowedCSIDrivers {
2209			dAtA[i] = 0xba
2210			i++
2211			dAtA[i] = 0x1
2212			i++
2213			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2214			n, err := msg.MarshalTo(dAtA[i:])
2215			if err != nil {
2216				return 0, err
2217			}
2218			i += n
2219		}
2220	}
2221	return i, nil
2222}
2223
2224func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
2225	size := m.Size()
2226	dAtA = make([]byte, size)
2227	n, err := m.MarshalTo(dAtA)
2228	if err != nil {
2229		return nil, err
2230	}
2231	return dAtA[:n], nil
2232}
2233
2234func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
2235	var i int
2236	_ = i
2237	var l int
2238	_ = l
2239	dAtA[i] = 0xa
2240	i++
2241	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2242	n48, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2243	if err != nil {
2244		return 0, err
2245	}
2246	i += n48
2247	dAtA[i] = 0x12
2248	i++
2249	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2250	n49, err := m.Spec.MarshalTo(dAtA[i:])
2251	if err != nil {
2252		return 0, err
2253	}
2254	i += n49
2255	dAtA[i] = 0x1a
2256	i++
2257	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2258	n50, err := m.Status.MarshalTo(dAtA[i:])
2259	if err != nil {
2260		return 0, err
2261	}
2262	i += n50
2263	return i, nil
2264}
2265
2266func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
2267	size := m.Size()
2268	dAtA = make([]byte, size)
2269	n, err := m.MarshalTo(dAtA)
2270	if err != nil {
2271		return nil, err
2272	}
2273	return dAtA[:n], nil
2274}
2275
2276func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
2277	var i int
2278	_ = i
2279	var l int
2280	_ = l
2281	dAtA[i] = 0xa
2282	i++
2283	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2284	i += copy(dAtA[i:], m.Type)
2285	dAtA[i] = 0x12
2286	i++
2287	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
2288	i += copy(dAtA[i:], m.Status)
2289	dAtA[i] = 0x1a
2290	i++
2291	i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
2292	n51, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
2293	if err != nil {
2294		return 0, err
2295	}
2296	i += n51
2297	dAtA[i] = 0x22
2298	i++
2299	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
2300	i += copy(dAtA[i:], m.Reason)
2301	dAtA[i] = 0x2a
2302	i++
2303	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
2304	i += copy(dAtA[i:], m.Message)
2305	return i, nil
2306}
2307
2308func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
2309	size := m.Size()
2310	dAtA = make([]byte, size)
2311	n, err := m.MarshalTo(dAtA)
2312	if err != nil {
2313		return nil, err
2314	}
2315	return dAtA[:n], nil
2316}
2317
2318func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
2319	var i int
2320	_ = i
2321	var l int
2322	_ = l
2323	dAtA[i] = 0xa
2324	i++
2325	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
2326	n52, err := m.ListMeta.MarshalTo(dAtA[i:])
2327	if err != nil {
2328		return 0, err
2329	}
2330	i += n52
2331	if len(m.Items) > 0 {
2332		for _, msg := range m.Items {
2333			dAtA[i] = 0x12
2334			i++
2335			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2336			n, err := msg.MarshalTo(dAtA[i:])
2337			if err != nil {
2338				return 0, err
2339			}
2340			i += n
2341		}
2342	}
2343	return i, nil
2344}
2345
2346func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
2347	size := m.Size()
2348	dAtA = make([]byte, size)
2349	n, err := m.MarshalTo(dAtA)
2350	if err != nil {
2351		return nil, err
2352	}
2353	return dAtA[:n], nil
2354}
2355
2356func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
2357	var i int
2358	_ = i
2359	var l int
2360	_ = l
2361	if m.Replicas != nil {
2362		dAtA[i] = 0x8
2363		i++
2364		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
2365	}
2366	if m.Selector != nil {
2367		dAtA[i] = 0x12
2368		i++
2369		i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
2370		n53, err := m.Selector.MarshalTo(dAtA[i:])
2371		if err != nil {
2372			return 0, err
2373		}
2374		i += n53
2375	}
2376	dAtA[i] = 0x1a
2377	i++
2378	i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
2379	n54, err := m.Template.MarshalTo(dAtA[i:])
2380	if err != nil {
2381		return 0, err
2382	}
2383	i += n54
2384	dAtA[i] = 0x20
2385	i++
2386	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
2387	return i, nil
2388}
2389
2390func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
2391	size := m.Size()
2392	dAtA = make([]byte, size)
2393	n, err := m.MarshalTo(dAtA)
2394	if err != nil {
2395		return nil, err
2396	}
2397	return dAtA[:n], nil
2398}
2399
2400func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
2401	var i int
2402	_ = i
2403	var l int
2404	_ = l
2405	dAtA[i] = 0x8
2406	i++
2407	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2408	dAtA[i] = 0x10
2409	i++
2410	i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
2411	dAtA[i] = 0x18
2412	i++
2413	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
2414	dAtA[i] = 0x20
2415	i++
2416	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2417	dAtA[i] = 0x28
2418	i++
2419	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
2420	if len(m.Conditions) > 0 {
2421		for _, msg := range m.Conditions {
2422			dAtA[i] = 0x32
2423			i++
2424			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2425			n, err := msg.MarshalTo(dAtA[i:])
2426			if err != nil {
2427				return 0, err
2428			}
2429			i += n
2430		}
2431	}
2432	return i, nil
2433}
2434
2435func (m *ReplicationControllerDummy) Marshal() (dAtA []byte, err error) {
2436	size := m.Size()
2437	dAtA = make([]byte, size)
2438	n, err := m.MarshalTo(dAtA)
2439	if err != nil {
2440		return nil, err
2441	}
2442	return dAtA[:n], nil
2443}
2444
2445func (m *ReplicationControllerDummy) MarshalTo(dAtA []byte) (int, error) {
2446	var i int
2447	_ = i
2448	var l int
2449	_ = l
2450	return i, nil
2451}
2452
2453func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
2454	size := m.Size()
2455	dAtA = make([]byte, size)
2456	n, err := m.MarshalTo(dAtA)
2457	if err != nil {
2458		return nil, err
2459	}
2460	return dAtA[:n], nil
2461}
2462
2463func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
2464	var i int
2465	_ = i
2466	var l int
2467	_ = l
2468	dAtA[i] = 0x8
2469	i++
2470	i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
2471	return i, nil
2472}
2473
2474func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
2475	size := m.Size()
2476	dAtA = make([]byte, size)
2477	n, err := m.MarshalTo(dAtA)
2478	if err != nil {
2479		return nil, err
2480	}
2481	return dAtA[:n], nil
2482}
2483
2484func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
2485	var i int
2486	_ = i
2487	var l int
2488	_ = l
2489	if m.MaxUnavailable != nil {
2490		dAtA[i] = 0xa
2491		i++
2492		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2493		n55, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2494		if err != nil {
2495			return 0, err
2496		}
2497		i += n55
2498	}
2499	return i, nil
2500}
2501
2502func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
2503	size := m.Size()
2504	dAtA = make([]byte, size)
2505	n, err := m.MarshalTo(dAtA)
2506	if err != nil {
2507		return nil, err
2508	}
2509	return dAtA[:n], nil
2510}
2511
2512func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
2513	var i int
2514	_ = i
2515	var l int
2516	_ = l
2517	if m.MaxUnavailable != nil {
2518		dAtA[i] = 0xa
2519		i++
2520		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
2521		n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
2522		if err != nil {
2523			return 0, err
2524		}
2525		i += n56
2526	}
2527	if m.MaxSurge != nil {
2528		dAtA[i] = 0x12
2529		i++
2530		i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
2531		n57, err := m.MaxSurge.MarshalTo(dAtA[i:])
2532		if err != nil {
2533			return 0, err
2534		}
2535		i += n57
2536	}
2537	return i, nil
2538}
2539
2540func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) {
2541	size := m.Size()
2542	dAtA = make([]byte, size)
2543	n, err := m.MarshalTo(dAtA)
2544	if err != nil {
2545		return nil, err
2546	}
2547	return dAtA[:n], nil
2548}
2549
2550func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2551	var i int
2552	_ = i
2553	var l int
2554	_ = l
2555	dAtA[i] = 0xa
2556	i++
2557	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2558	i += copy(dAtA[i:], m.Rule)
2559	if len(m.Ranges) > 0 {
2560		for _, msg := range m.Ranges {
2561			dAtA[i] = 0x12
2562			i++
2563			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2564			n, err := msg.MarshalTo(dAtA[i:])
2565			if err != nil {
2566				return 0, err
2567			}
2568			i += n
2569		}
2570	}
2571	return i, nil
2572}
2573
2574func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) {
2575	size := m.Size()
2576	dAtA = make([]byte, size)
2577	n, err := m.MarshalTo(dAtA)
2578	if err != nil {
2579		return nil, err
2580	}
2581	return dAtA[:n], nil
2582}
2583
2584func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2585	var i int
2586	_ = i
2587	var l int
2588	_ = l
2589	dAtA[i] = 0xa
2590	i++
2591	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2592	i += copy(dAtA[i:], m.Rule)
2593	if len(m.Ranges) > 0 {
2594		for _, msg := range m.Ranges {
2595			dAtA[i] = 0x12
2596			i++
2597			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2598			n, err := msg.MarshalTo(dAtA[i:])
2599			if err != nil {
2600				return 0, err
2601			}
2602			i += n
2603		}
2604	}
2605	return i, nil
2606}
2607
2608func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) {
2609	size := m.Size()
2610	dAtA = make([]byte, size)
2611	n, err := m.MarshalTo(dAtA)
2612	if err != nil {
2613		return nil, err
2614	}
2615	return dAtA[:n], nil
2616}
2617
2618func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2619	var i int
2620	_ = i
2621	var l int
2622	_ = l
2623	dAtA[i] = 0xa
2624	i++
2625	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2626	i += copy(dAtA[i:], m.Rule)
2627	if m.SELinuxOptions != nil {
2628		dAtA[i] = 0x12
2629		i++
2630		i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size()))
2631		n58, err := m.SELinuxOptions.MarshalTo(dAtA[i:])
2632		if err != nil {
2633			return 0, err
2634		}
2635		i += n58
2636	}
2637	return i, nil
2638}
2639
2640func (m *Scale) Marshal() (dAtA []byte, err error) {
2641	size := m.Size()
2642	dAtA = make([]byte, size)
2643	n, err := m.MarshalTo(dAtA)
2644	if err != nil {
2645		return nil, err
2646	}
2647	return dAtA[:n], nil
2648}
2649
2650func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
2651	var i int
2652	_ = i
2653	var l int
2654	_ = l
2655	dAtA[i] = 0xa
2656	i++
2657	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
2658	n59, err := m.ObjectMeta.MarshalTo(dAtA[i:])
2659	if err != nil {
2660		return 0, err
2661	}
2662	i += n59
2663	dAtA[i] = 0x12
2664	i++
2665	i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2666	n60, err := m.Spec.MarshalTo(dAtA[i:])
2667	if err != nil {
2668		return 0, err
2669	}
2670	i += n60
2671	dAtA[i] = 0x1a
2672	i++
2673	i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
2674	n61, err := m.Status.MarshalTo(dAtA[i:])
2675	if err != nil {
2676		return 0, err
2677	}
2678	i += n61
2679	return i, nil
2680}
2681
2682func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
2683	size := m.Size()
2684	dAtA = make([]byte, size)
2685	n, err := m.MarshalTo(dAtA)
2686	if err != nil {
2687		return nil, err
2688	}
2689	return dAtA[:n], nil
2690}
2691
2692func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
2693	var i int
2694	_ = i
2695	var l int
2696	_ = l
2697	dAtA[i] = 0x8
2698	i++
2699	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2700	return i, nil
2701}
2702
2703func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
2704	size := m.Size()
2705	dAtA = make([]byte, size)
2706	n, err := m.MarshalTo(dAtA)
2707	if err != nil {
2708		return nil, err
2709	}
2710	return dAtA[:n], nil
2711}
2712
2713func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
2714	var i int
2715	_ = i
2716	var l int
2717	_ = l
2718	dAtA[i] = 0x8
2719	i++
2720	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2721	if len(m.Selector) > 0 {
2722		keysForSelector := make([]string, 0, len(m.Selector))
2723		for k := range m.Selector {
2724			keysForSelector = append(keysForSelector, string(k))
2725		}
2726		github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
2727		for _, k := range keysForSelector {
2728			dAtA[i] = 0x12
2729			i++
2730			v := m.Selector[string(k)]
2731			mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2732			i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
2733			dAtA[i] = 0xa
2734			i++
2735			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
2736			i += copy(dAtA[i:], k)
2737			dAtA[i] = 0x12
2738			i++
2739			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
2740			i += copy(dAtA[i:], v)
2741		}
2742	}
2743	dAtA[i] = 0x1a
2744	i++
2745	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
2746	i += copy(dAtA[i:], m.TargetSelector)
2747	return i, nil
2748}
2749
2750func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) {
2751	size := m.Size()
2752	dAtA = make([]byte, size)
2753	n, err := m.MarshalTo(dAtA)
2754	if err != nil {
2755		return nil, err
2756	}
2757	return dAtA[:n], nil
2758}
2759
2760func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) {
2761	var i int
2762	_ = i
2763	var l int
2764	_ = l
2765	dAtA[i] = 0xa
2766	i++
2767	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule)))
2768	i += copy(dAtA[i:], m.Rule)
2769	if len(m.Ranges) > 0 {
2770		for _, msg := range m.Ranges {
2771			dAtA[i] = 0x12
2772			i++
2773			i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
2774			n, err := msg.MarshalTo(dAtA[i:])
2775			if err != nil {
2776				return 0, err
2777			}
2778			i += n
2779		}
2780	}
2781	return i, nil
2782}
2783
2784func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2785	for v >= 1<<7 {
2786		dAtA[offset] = uint8(v&0x7f | 0x80)
2787		v >>= 7
2788		offset++
2789	}
2790	dAtA[offset] = uint8(v)
2791	return offset + 1
2792}
2793func (m *AllowedCSIDriver) Size() (n int) {
2794	var l int
2795	_ = l
2796	l = len(m.Name)
2797	n += 1 + l + sovGenerated(uint64(l))
2798	return n
2799}
2800
2801func (m *AllowedFlexVolume) Size() (n int) {
2802	var l int
2803	_ = l
2804	l = len(m.Driver)
2805	n += 1 + l + sovGenerated(uint64(l))
2806	return n
2807}
2808
2809func (m *AllowedHostPath) Size() (n int) {
2810	var l int
2811	_ = l
2812	l = len(m.PathPrefix)
2813	n += 1 + l + sovGenerated(uint64(l))
2814	n += 2
2815	return n
2816}
2817
2818func (m *DaemonSet) Size() (n int) {
2819	var l int
2820	_ = l
2821	l = m.ObjectMeta.Size()
2822	n += 1 + l + sovGenerated(uint64(l))
2823	l = m.Spec.Size()
2824	n += 1 + l + sovGenerated(uint64(l))
2825	l = m.Status.Size()
2826	n += 1 + l + sovGenerated(uint64(l))
2827	return n
2828}
2829
2830func (m *DaemonSetCondition) Size() (n int) {
2831	var l int
2832	_ = l
2833	l = len(m.Type)
2834	n += 1 + l + sovGenerated(uint64(l))
2835	l = len(m.Status)
2836	n += 1 + l + sovGenerated(uint64(l))
2837	l = m.LastTransitionTime.Size()
2838	n += 1 + l + sovGenerated(uint64(l))
2839	l = len(m.Reason)
2840	n += 1 + l + sovGenerated(uint64(l))
2841	l = len(m.Message)
2842	n += 1 + l + sovGenerated(uint64(l))
2843	return n
2844}
2845
2846func (m *DaemonSetList) Size() (n int) {
2847	var l int
2848	_ = l
2849	l = m.ListMeta.Size()
2850	n += 1 + l + sovGenerated(uint64(l))
2851	if len(m.Items) > 0 {
2852		for _, e := range m.Items {
2853			l = e.Size()
2854			n += 1 + l + sovGenerated(uint64(l))
2855		}
2856	}
2857	return n
2858}
2859
2860func (m *DaemonSetSpec) Size() (n int) {
2861	var l int
2862	_ = l
2863	if m.Selector != nil {
2864		l = m.Selector.Size()
2865		n += 1 + l + sovGenerated(uint64(l))
2866	}
2867	l = m.Template.Size()
2868	n += 1 + l + sovGenerated(uint64(l))
2869	l = m.UpdateStrategy.Size()
2870	n += 1 + l + sovGenerated(uint64(l))
2871	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2872	n += 1 + sovGenerated(uint64(m.TemplateGeneration))
2873	if m.RevisionHistoryLimit != nil {
2874		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2875	}
2876	return n
2877}
2878
2879func (m *DaemonSetStatus) Size() (n int) {
2880	var l int
2881	_ = l
2882	n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
2883	n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
2884	n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
2885	n += 1 + sovGenerated(uint64(m.NumberReady))
2886	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2887	n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
2888	n += 1 + sovGenerated(uint64(m.NumberAvailable))
2889	n += 1 + sovGenerated(uint64(m.NumberUnavailable))
2890	if m.CollisionCount != nil {
2891		n += 1 + sovGenerated(uint64(*m.CollisionCount))
2892	}
2893	if len(m.Conditions) > 0 {
2894		for _, e := range m.Conditions {
2895			l = e.Size()
2896			n += 1 + l + sovGenerated(uint64(l))
2897		}
2898	}
2899	return n
2900}
2901
2902func (m *DaemonSetUpdateStrategy) Size() (n int) {
2903	var l int
2904	_ = l
2905	l = len(m.Type)
2906	n += 1 + l + sovGenerated(uint64(l))
2907	if m.RollingUpdate != nil {
2908		l = m.RollingUpdate.Size()
2909		n += 1 + l + sovGenerated(uint64(l))
2910	}
2911	return n
2912}
2913
2914func (m *Deployment) Size() (n int) {
2915	var l int
2916	_ = l
2917	l = m.ObjectMeta.Size()
2918	n += 1 + l + sovGenerated(uint64(l))
2919	l = m.Spec.Size()
2920	n += 1 + l + sovGenerated(uint64(l))
2921	l = m.Status.Size()
2922	n += 1 + l + sovGenerated(uint64(l))
2923	return n
2924}
2925
2926func (m *DeploymentCondition) Size() (n int) {
2927	var l int
2928	_ = l
2929	l = len(m.Type)
2930	n += 1 + l + sovGenerated(uint64(l))
2931	l = len(m.Status)
2932	n += 1 + l + sovGenerated(uint64(l))
2933	l = len(m.Reason)
2934	n += 1 + l + sovGenerated(uint64(l))
2935	l = len(m.Message)
2936	n += 1 + l + sovGenerated(uint64(l))
2937	l = m.LastUpdateTime.Size()
2938	n += 1 + l + sovGenerated(uint64(l))
2939	l = m.LastTransitionTime.Size()
2940	n += 1 + l + sovGenerated(uint64(l))
2941	return n
2942}
2943
2944func (m *DeploymentList) Size() (n int) {
2945	var l int
2946	_ = l
2947	l = m.ListMeta.Size()
2948	n += 1 + l + sovGenerated(uint64(l))
2949	if len(m.Items) > 0 {
2950		for _, e := range m.Items {
2951			l = e.Size()
2952			n += 1 + l + sovGenerated(uint64(l))
2953		}
2954	}
2955	return n
2956}
2957
2958func (m *DeploymentRollback) Size() (n int) {
2959	var l int
2960	_ = l
2961	l = len(m.Name)
2962	n += 1 + l + sovGenerated(uint64(l))
2963	if len(m.UpdatedAnnotations) > 0 {
2964		for k, v := range m.UpdatedAnnotations {
2965			_ = k
2966			_ = v
2967			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2968			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2969		}
2970	}
2971	l = m.RollbackTo.Size()
2972	n += 1 + l + sovGenerated(uint64(l))
2973	return n
2974}
2975
2976func (m *DeploymentSpec) Size() (n int) {
2977	var l int
2978	_ = l
2979	if m.Replicas != nil {
2980		n += 1 + sovGenerated(uint64(*m.Replicas))
2981	}
2982	if m.Selector != nil {
2983		l = m.Selector.Size()
2984		n += 1 + l + sovGenerated(uint64(l))
2985	}
2986	l = m.Template.Size()
2987	n += 1 + l + sovGenerated(uint64(l))
2988	l = m.Strategy.Size()
2989	n += 1 + l + sovGenerated(uint64(l))
2990	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2991	if m.RevisionHistoryLimit != nil {
2992		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2993	}
2994	n += 2
2995	if m.RollbackTo != nil {
2996		l = m.RollbackTo.Size()
2997		n += 1 + l + sovGenerated(uint64(l))
2998	}
2999	if m.ProgressDeadlineSeconds != nil {
3000		n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
3001	}
3002	return n
3003}
3004
3005func (m *DeploymentStatus) Size() (n int) {
3006	var l int
3007	_ = l
3008	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3009	n += 1 + sovGenerated(uint64(m.Replicas))
3010	n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
3011	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3012	n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
3013	if len(m.Conditions) > 0 {
3014		for _, e := range m.Conditions {
3015			l = e.Size()
3016			n += 1 + l + sovGenerated(uint64(l))
3017		}
3018	}
3019	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3020	if m.CollisionCount != nil {
3021		n += 1 + sovGenerated(uint64(*m.CollisionCount))
3022	}
3023	return n
3024}
3025
3026func (m *DeploymentStrategy) Size() (n int) {
3027	var l int
3028	_ = l
3029	l = len(m.Type)
3030	n += 1 + l + sovGenerated(uint64(l))
3031	if m.RollingUpdate != nil {
3032		l = m.RollingUpdate.Size()
3033		n += 1 + l + sovGenerated(uint64(l))
3034	}
3035	return n
3036}
3037
3038func (m *FSGroupStrategyOptions) Size() (n int) {
3039	var l int
3040	_ = l
3041	l = len(m.Rule)
3042	n += 1 + l + sovGenerated(uint64(l))
3043	if len(m.Ranges) > 0 {
3044		for _, e := range m.Ranges {
3045			l = e.Size()
3046			n += 1 + l + sovGenerated(uint64(l))
3047		}
3048	}
3049	return n
3050}
3051
3052func (m *HTTPIngressPath) Size() (n int) {
3053	var l int
3054	_ = l
3055	l = len(m.Path)
3056	n += 1 + l + sovGenerated(uint64(l))
3057	l = m.Backend.Size()
3058	n += 1 + l + sovGenerated(uint64(l))
3059	return n
3060}
3061
3062func (m *HTTPIngressRuleValue) Size() (n int) {
3063	var l int
3064	_ = l
3065	if len(m.Paths) > 0 {
3066		for _, e := range m.Paths {
3067			l = e.Size()
3068			n += 1 + l + sovGenerated(uint64(l))
3069		}
3070	}
3071	return n
3072}
3073
3074func (m *HostPortRange) Size() (n int) {
3075	var l int
3076	_ = l
3077	n += 1 + sovGenerated(uint64(m.Min))
3078	n += 1 + sovGenerated(uint64(m.Max))
3079	return n
3080}
3081
3082func (m *IDRange) Size() (n int) {
3083	var l int
3084	_ = l
3085	n += 1 + sovGenerated(uint64(m.Min))
3086	n += 1 + sovGenerated(uint64(m.Max))
3087	return n
3088}
3089
3090func (m *IPBlock) Size() (n int) {
3091	var l int
3092	_ = l
3093	l = len(m.CIDR)
3094	n += 1 + l + sovGenerated(uint64(l))
3095	if len(m.Except) > 0 {
3096		for _, s := range m.Except {
3097			l = len(s)
3098			n += 1 + l + sovGenerated(uint64(l))
3099		}
3100	}
3101	return n
3102}
3103
3104func (m *Ingress) Size() (n int) {
3105	var l int
3106	_ = l
3107	l = m.ObjectMeta.Size()
3108	n += 1 + l + sovGenerated(uint64(l))
3109	l = m.Spec.Size()
3110	n += 1 + l + sovGenerated(uint64(l))
3111	l = m.Status.Size()
3112	n += 1 + l + sovGenerated(uint64(l))
3113	return n
3114}
3115
3116func (m *IngressBackend) Size() (n int) {
3117	var l int
3118	_ = l
3119	l = len(m.ServiceName)
3120	n += 1 + l + sovGenerated(uint64(l))
3121	l = m.ServicePort.Size()
3122	n += 1 + l + sovGenerated(uint64(l))
3123	return n
3124}
3125
3126func (m *IngressList) Size() (n int) {
3127	var l int
3128	_ = l
3129	l = m.ListMeta.Size()
3130	n += 1 + l + sovGenerated(uint64(l))
3131	if len(m.Items) > 0 {
3132		for _, e := range m.Items {
3133			l = e.Size()
3134			n += 1 + l + sovGenerated(uint64(l))
3135		}
3136	}
3137	return n
3138}
3139
3140func (m *IngressRule) Size() (n int) {
3141	var l int
3142	_ = l
3143	l = len(m.Host)
3144	n += 1 + l + sovGenerated(uint64(l))
3145	l = m.IngressRuleValue.Size()
3146	n += 1 + l + sovGenerated(uint64(l))
3147	return n
3148}
3149
3150func (m *IngressRuleValue) Size() (n int) {
3151	var l int
3152	_ = l
3153	if m.HTTP != nil {
3154		l = m.HTTP.Size()
3155		n += 1 + l + sovGenerated(uint64(l))
3156	}
3157	return n
3158}
3159
3160func (m *IngressSpec) Size() (n int) {
3161	var l int
3162	_ = l
3163	if m.Backend != nil {
3164		l = m.Backend.Size()
3165		n += 1 + l + sovGenerated(uint64(l))
3166	}
3167	if len(m.TLS) > 0 {
3168		for _, e := range m.TLS {
3169			l = e.Size()
3170			n += 1 + l + sovGenerated(uint64(l))
3171		}
3172	}
3173	if len(m.Rules) > 0 {
3174		for _, e := range m.Rules {
3175			l = e.Size()
3176			n += 1 + l + sovGenerated(uint64(l))
3177		}
3178	}
3179	return n
3180}
3181
3182func (m *IngressStatus) Size() (n int) {
3183	var l int
3184	_ = l
3185	l = m.LoadBalancer.Size()
3186	n += 1 + l + sovGenerated(uint64(l))
3187	return n
3188}
3189
3190func (m *IngressTLS) Size() (n int) {
3191	var l int
3192	_ = l
3193	if len(m.Hosts) > 0 {
3194		for _, s := range m.Hosts {
3195			l = len(s)
3196			n += 1 + l + sovGenerated(uint64(l))
3197		}
3198	}
3199	l = len(m.SecretName)
3200	n += 1 + l + sovGenerated(uint64(l))
3201	return n
3202}
3203
3204func (m *NetworkPolicy) Size() (n int) {
3205	var l int
3206	_ = l
3207	l = m.ObjectMeta.Size()
3208	n += 1 + l + sovGenerated(uint64(l))
3209	l = m.Spec.Size()
3210	n += 1 + l + sovGenerated(uint64(l))
3211	return n
3212}
3213
3214func (m *NetworkPolicyEgressRule) Size() (n int) {
3215	var l int
3216	_ = l
3217	if len(m.Ports) > 0 {
3218		for _, e := range m.Ports {
3219			l = e.Size()
3220			n += 1 + l + sovGenerated(uint64(l))
3221		}
3222	}
3223	if len(m.To) > 0 {
3224		for _, e := range m.To {
3225			l = e.Size()
3226			n += 1 + l + sovGenerated(uint64(l))
3227		}
3228	}
3229	return n
3230}
3231
3232func (m *NetworkPolicyIngressRule) Size() (n int) {
3233	var l int
3234	_ = l
3235	if len(m.Ports) > 0 {
3236		for _, e := range m.Ports {
3237			l = e.Size()
3238			n += 1 + l + sovGenerated(uint64(l))
3239		}
3240	}
3241	if len(m.From) > 0 {
3242		for _, e := range m.From {
3243			l = e.Size()
3244			n += 1 + l + sovGenerated(uint64(l))
3245		}
3246	}
3247	return n
3248}
3249
3250func (m *NetworkPolicyList) Size() (n int) {
3251	var l int
3252	_ = l
3253	l = m.ListMeta.Size()
3254	n += 1 + l + sovGenerated(uint64(l))
3255	if len(m.Items) > 0 {
3256		for _, e := range m.Items {
3257			l = e.Size()
3258			n += 1 + l + sovGenerated(uint64(l))
3259		}
3260	}
3261	return n
3262}
3263
3264func (m *NetworkPolicyPeer) Size() (n int) {
3265	var l int
3266	_ = l
3267	if m.PodSelector != nil {
3268		l = m.PodSelector.Size()
3269		n += 1 + l + sovGenerated(uint64(l))
3270	}
3271	if m.NamespaceSelector != nil {
3272		l = m.NamespaceSelector.Size()
3273		n += 1 + l + sovGenerated(uint64(l))
3274	}
3275	if m.IPBlock != nil {
3276		l = m.IPBlock.Size()
3277		n += 1 + l + sovGenerated(uint64(l))
3278	}
3279	return n
3280}
3281
3282func (m *NetworkPolicyPort) Size() (n int) {
3283	var l int
3284	_ = l
3285	if m.Protocol != nil {
3286		l = len(*m.Protocol)
3287		n += 1 + l + sovGenerated(uint64(l))
3288	}
3289	if m.Port != nil {
3290		l = m.Port.Size()
3291		n += 1 + l + sovGenerated(uint64(l))
3292	}
3293	return n
3294}
3295
3296func (m *NetworkPolicySpec) Size() (n int) {
3297	var l int
3298	_ = l
3299	l = m.PodSelector.Size()
3300	n += 1 + l + sovGenerated(uint64(l))
3301	if len(m.Ingress) > 0 {
3302		for _, e := range m.Ingress {
3303			l = e.Size()
3304			n += 1 + l + sovGenerated(uint64(l))
3305		}
3306	}
3307	if len(m.Egress) > 0 {
3308		for _, e := range m.Egress {
3309			l = e.Size()
3310			n += 1 + l + sovGenerated(uint64(l))
3311		}
3312	}
3313	if len(m.PolicyTypes) > 0 {
3314		for _, s := range m.PolicyTypes {
3315			l = len(s)
3316			n += 1 + l + sovGenerated(uint64(l))
3317		}
3318	}
3319	return n
3320}
3321
3322func (m *PodSecurityPolicy) Size() (n int) {
3323	var l int
3324	_ = l
3325	l = m.ObjectMeta.Size()
3326	n += 1 + l + sovGenerated(uint64(l))
3327	l = m.Spec.Size()
3328	n += 1 + l + sovGenerated(uint64(l))
3329	return n
3330}
3331
3332func (m *PodSecurityPolicyList) Size() (n int) {
3333	var l int
3334	_ = l
3335	l = m.ListMeta.Size()
3336	n += 1 + l + sovGenerated(uint64(l))
3337	if len(m.Items) > 0 {
3338		for _, e := range m.Items {
3339			l = e.Size()
3340			n += 1 + l + sovGenerated(uint64(l))
3341		}
3342	}
3343	return n
3344}
3345
3346func (m *PodSecurityPolicySpec) Size() (n int) {
3347	var l int
3348	_ = l
3349	n += 2
3350	if len(m.DefaultAddCapabilities) > 0 {
3351		for _, s := range m.DefaultAddCapabilities {
3352			l = len(s)
3353			n += 1 + l + sovGenerated(uint64(l))
3354		}
3355	}
3356	if len(m.RequiredDropCapabilities) > 0 {
3357		for _, s := range m.RequiredDropCapabilities {
3358			l = len(s)
3359			n += 1 + l + sovGenerated(uint64(l))
3360		}
3361	}
3362	if len(m.AllowedCapabilities) > 0 {
3363		for _, s := range m.AllowedCapabilities {
3364			l = len(s)
3365			n += 1 + l + sovGenerated(uint64(l))
3366		}
3367	}
3368	if len(m.Volumes) > 0 {
3369		for _, s := range m.Volumes {
3370			l = len(s)
3371			n += 1 + l + sovGenerated(uint64(l))
3372		}
3373	}
3374	n += 2
3375	if len(m.HostPorts) > 0 {
3376		for _, e := range m.HostPorts {
3377			l = e.Size()
3378			n += 1 + l + sovGenerated(uint64(l))
3379		}
3380	}
3381	n += 2
3382	n += 2
3383	l = m.SELinux.Size()
3384	n += 1 + l + sovGenerated(uint64(l))
3385	l = m.RunAsUser.Size()
3386	n += 1 + l + sovGenerated(uint64(l))
3387	l = m.SupplementalGroups.Size()
3388	n += 1 + l + sovGenerated(uint64(l))
3389	l = m.FSGroup.Size()
3390	n += 1 + l + sovGenerated(uint64(l))
3391	n += 2
3392	if m.DefaultAllowPrivilegeEscalation != nil {
3393		n += 2
3394	}
3395	if m.AllowPrivilegeEscalation != nil {
3396		n += 3
3397	}
3398	if len(m.AllowedHostPaths) > 0 {
3399		for _, e := range m.AllowedHostPaths {
3400			l = e.Size()
3401			n += 2 + l + sovGenerated(uint64(l))
3402		}
3403	}
3404	if len(m.AllowedFlexVolumes) > 0 {
3405		for _, e := range m.AllowedFlexVolumes {
3406			l = e.Size()
3407			n += 2 + l + sovGenerated(uint64(l))
3408		}
3409	}
3410	if len(m.AllowedUnsafeSysctls) > 0 {
3411		for _, s := range m.AllowedUnsafeSysctls {
3412			l = len(s)
3413			n += 2 + l + sovGenerated(uint64(l))
3414		}
3415	}
3416	if len(m.ForbiddenSysctls) > 0 {
3417		for _, s := range m.ForbiddenSysctls {
3418			l = len(s)
3419			n += 2 + l + sovGenerated(uint64(l))
3420		}
3421	}
3422	if len(m.AllowedProcMountTypes) > 0 {
3423		for _, s := range m.AllowedProcMountTypes {
3424			l = len(s)
3425			n += 2 + l + sovGenerated(uint64(l))
3426		}
3427	}
3428	if m.RunAsGroup != nil {
3429		l = m.RunAsGroup.Size()
3430		n += 2 + l + sovGenerated(uint64(l))
3431	}
3432	if len(m.AllowedCSIDrivers) > 0 {
3433		for _, e := range m.AllowedCSIDrivers {
3434			l = e.Size()
3435			n += 2 + l + sovGenerated(uint64(l))
3436		}
3437	}
3438	return n
3439}
3440
3441func (m *ReplicaSet) Size() (n int) {
3442	var l int
3443	_ = l
3444	l = m.ObjectMeta.Size()
3445	n += 1 + l + sovGenerated(uint64(l))
3446	l = m.Spec.Size()
3447	n += 1 + l + sovGenerated(uint64(l))
3448	l = m.Status.Size()
3449	n += 1 + l + sovGenerated(uint64(l))
3450	return n
3451}
3452
3453func (m *ReplicaSetCondition) Size() (n int) {
3454	var l int
3455	_ = l
3456	l = len(m.Type)
3457	n += 1 + l + sovGenerated(uint64(l))
3458	l = len(m.Status)
3459	n += 1 + l + sovGenerated(uint64(l))
3460	l = m.LastTransitionTime.Size()
3461	n += 1 + l + sovGenerated(uint64(l))
3462	l = len(m.Reason)
3463	n += 1 + l + sovGenerated(uint64(l))
3464	l = len(m.Message)
3465	n += 1 + l + sovGenerated(uint64(l))
3466	return n
3467}
3468
3469func (m *ReplicaSetList) Size() (n int) {
3470	var l int
3471	_ = l
3472	l = m.ListMeta.Size()
3473	n += 1 + l + sovGenerated(uint64(l))
3474	if len(m.Items) > 0 {
3475		for _, e := range m.Items {
3476			l = e.Size()
3477			n += 1 + l + sovGenerated(uint64(l))
3478		}
3479	}
3480	return n
3481}
3482
3483func (m *ReplicaSetSpec) Size() (n int) {
3484	var l int
3485	_ = l
3486	if m.Replicas != nil {
3487		n += 1 + sovGenerated(uint64(*m.Replicas))
3488	}
3489	if m.Selector != nil {
3490		l = m.Selector.Size()
3491		n += 1 + l + sovGenerated(uint64(l))
3492	}
3493	l = m.Template.Size()
3494	n += 1 + l + sovGenerated(uint64(l))
3495	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
3496	return n
3497}
3498
3499func (m *ReplicaSetStatus) Size() (n int) {
3500	var l int
3501	_ = l
3502	n += 1 + sovGenerated(uint64(m.Replicas))
3503	n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
3504	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
3505	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
3506	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
3507	if len(m.Conditions) > 0 {
3508		for _, e := range m.Conditions {
3509			l = e.Size()
3510			n += 1 + l + sovGenerated(uint64(l))
3511		}
3512	}
3513	return n
3514}
3515
3516func (m *ReplicationControllerDummy) Size() (n int) {
3517	var l int
3518	_ = l
3519	return n
3520}
3521
3522func (m *RollbackConfig) Size() (n int) {
3523	var l int
3524	_ = l
3525	n += 1 + sovGenerated(uint64(m.Revision))
3526	return n
3527}
3528
3529func (m *RollingUpdateDaemonSet) Size() (n int) {
3530	var l int
3531	_ = l
3532	if m.MaxUnavailable != nil {
3533		l = m.MaxUnavailable.Size()
3534		n += 1 + l + sovGenerated(uint64(l))
3535	}
3536	return n
3537}
3538
3539func (m *RollingUpdateDeployment) Size() (n int) {
3540	var l int
3541	_ = l
3542	if m.MaxUnavailable != nil {
3543		l = m.MaxUnavailable.Size()
3544		n += 1 + l + sovGenerated(uint64(l))
3545	}
3546	if m.MaxSurge != nil {
3547		l = m.MaxSurge.Size()
3548		n += 1 + l + sovGenerated(uint64(l))
3549	}
3550	return n
3551}
3552
3553func (m *RunAsGroupStrategyOptions) Size() (n int) {
3554	var l int
3555	_ = l
3556	l = len(m.Rule)
3557	n += 1 + l + sovGenerated(uint64(l))
3558	if len(m.Ranges) > 0 {
3559		for _, e := range m.Ranges {
3560			l = e.Size()
3561			n += 1 + l + sovGenerated(uint64(l))
3562		}
3563	}
3564	return n
3565}
3566
3567func (m *RunAsUserStrategyOptions) Size() (n int) {
3568	var l int
3569	_ = l
3570	l = len(m.Rule)
3571	n += 1 + l + sovGenerated(uint64(l))
3572	if len(m.Ranges) > 0 {
3573		for _, e := range m.Ranges {
3574			l = e.Size()
3575			n += 1 + l + sovGenerated(uint64(l))
3576		}
3577	}
3578	return n
3579}
3580
3581func (m *SELinuxStrategyOptions) Size() (n int) {
3582	var l int
3583	_ = l
3584	l = len(m.Rule)
3585	n += 1 + l + sovGenerated(uint64(l))
3586	if m.SELinuxOptions != nil {
3587		l = m.SELinuxOptions.Size()
3588		n += 1 + l + sovGenerated(uint64(l))
3589	}
3590	return n
3591}
3592
3593func (m *Scale) Size() (n int) {
3594	var l int
3595	_ = l
3596	l = m.ObjectMeta.Size()
3597	n += 1 + l + sovGenerated(uint64(l))
3598	l = m.Spec.Size()
3599	n += 1 + l + sovGenerated(uint64(l))
3600	l = m.Status.Size()
3601	n += 1 + l + sovGenerated(uint64(l))
3602	return n
3603}
3604
3605func (m *ScaleSpec) Size() (n int) {
3606	var l int
3607	_ = l
3608	n += 1 + sovGenerated(uint64(m.Replicas))
3609	return n
3610}
3611
3612func (m *ScaleStatus) Size() (n int) {
3613	var l int
3614	_ = l
3615	n += 1 + sovGenerated(uint64(m.Replicas))
3616	if len(m.Selector) > 0 {
3617		for k, v := range m.Selector {
3618			_ = k
3619			_ = v
3620			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
3621			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
3622		}
3623	}
3624	l = len(m.TargetSelector)
3625	n += 1 + l + sovGenerated(uint64(l))
3626	return n
3627}
3628
3629func (m *SupplementalGroupsStrategyOptions) Size() (n int) {
3630	var l int
3631	_ = l
3632	l = len(m.Rule)
3633	n += 1 + l + sovGenerated(uint64(l))
3634	if len(m.Ranges) > 0 {
3635		for _, e := range m.Ranges {
3636			l = e.Size()
3637			n += 1 + l + sovGenerated(uint64(l))
3638		}
3639	}
3640	return n
3641}
3642
3643func sovGenerated(x uint64) (n int) {
3644	for {
3645		n++
3646		x >>= 7
3647		if x == 0 {
3648			break
3649		}
3650	}
3651	return n
3652}
3653func sozGenerated(x uint64) (n int) {
3654	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
3655}
3656func (this *AllowedCSIDriver) String() string {
3657	if this == nil {
3658		return "nil"
3659	}
3660	s := strings.Join([]string{`&AllowedCSIDriver{`,
3661		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3662		`}`,
3663	}, "")
3664	return s
3665}
3666func (this *AllowedFlexVolume) String() string {
3667	if this == nil {
3668		return "nil"
3669	}
3670	s := strings.Join([]string{`&AllowedFlexVolume{`,
3671		`Driver:` + fmt.Sprintf("%v", this.Driver) + `,`,
3672		`}`,
3673	}, "")
3674	return s
3675}
3676func (this *AllowedHostPath) String() string {
3677	if this == nil {
3678		return "nil"
3679	}
3680	s := strings.Join([]string{`&AllowedHostPath{`,
3681		`PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`,
3682		`ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`,
3683		`}`,
3684	}, "")
3685	return s
3686}
3687func (this *DaemonSet) String() string {
3688	if this == nil {
3689		return "nil"
3690	}
3691	s := strings.Join([]string{`&DaemonSet{`,
3692		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3693		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
3694		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
3695		`}`,
3696	}, "")
3697	return s
3698}
3699func (this *DaemonSetCondition) String() string {
3700	if this == nil {
3701		return "nil"
3702	}
3703	s := strings.Join([]string{`&DaemonSetCondition{`,
3704		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3705		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3706		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3707		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3708		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3709		`}`,
3710	}, "")
3711	return s
3712}
3713func (this *DaemonSetList) String() string {
3714	if this == nil {
3715		return "nil"
3716	}
3717	s := strings.Join([]string{`&DaemonSetList{`,
3718		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3719		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`,
3720		`}`,
3721	}, "")
3722	return s
3723}
3724func (this *DaemonSetSpec) String() string {
3725	if this == nil {
3726		return "nil"
3727	}
3728	s := strings.Join([]string{`&DaemonSetSpec{`,
3729		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3730		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3731		`UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
3732		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3733		`TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`,
3734		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3735		`}`,
3736	}, "")
3737	return s
3738}
3739func (this *DaemonSetStatus) String() string {
3740	if this == nil {
3741		return "nil"
3742	}
3743	s := strings.Join([]string{`&DaemonSetStatus{`,
3744		`CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
3745		`NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
3746		`DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
3747		`NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
3748		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3749		`UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
3750		`NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
3751		`NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
3752		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3753		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`,
3754		`}`,
3755	}, "")
3756	return s
3757}
3758func (this *DaemonSetUpdateStrategy) String() string {
3759	if this == nil {
3760		return "nil"
3761	}
3762	s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
3763		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3764		`RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
3765		`}`,
3766	}, "")
3767	return s
3768}
3769func (this *Deployment) String() string {
3770	if this == nil {
3771		return "nil"
3772	}
3773	s := strings.Join([]string{`&Deployment{`,
3774		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3775		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
3776		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
3777		`}`,
3778	}, "")
3779	return s
3780}
3781func (this *DeploymentCondition) String() string {
3782	if this == nil {
3783		return "nil"
3784	}
3785	s := strings.Join([]string{`&DeploymentCondition{`,
3786		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3787		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
3788		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
3789		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
3790		`LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3791		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
3792		`}`,
3793	}, "")
3794	return s
3795}
3796func (this *DeploymentList) String() string {
3797	if this == nil {
3798		return "nil"
3799	}
3800	s := strings.Join([]string{`&DeploymentList{`,
3801		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3802		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`,
3803		`}`,
3804	}, "")
3805	return s
3806}
3807func (this *DeploymentRollback) String() string {
3808	if this == nil {
3809		return "nil"
3810	}
3811	keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
3812	for k := range this.UpdatedAnnotations {
3813		keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
3814	}
3815	github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
3816	mapStringForUpdatedAnnotations := "map[string]string{"
3817	for _, k := range keysForUpdatedAnnotations {
3818		mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
3819	}
3820	mapStringForUpdatedAnnotations += "}"
3821	s := strings.Join([]string{`&DeploymentRollback{`,
3822		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
3823		`UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
3824		`RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
3825		`}`,
3826	}, "")
3827	return s
3828}
3829func (this *DeploymentSpec) String() string {
3830	if this == nil {
3831		return "nil"
3832	}
3833	s := strings.Join([]string{`&DeploymentSpec{`,
3834		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
3835		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
3836		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
3837		`Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
3838		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
3839		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
3840		`Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
3841		`RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`,
3842		`ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
3843		`}`,
3844	}, "")
3845	return s
3846}
3847func (this *DeploymentStatus) String() string {
3848	if this == nil {
3849		return "nil"
3850	}
3851	s := strings.Join([]string{`&DeploymentStatus{`,
3852		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
3853		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
3854		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
3855		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
3856		`UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
3857		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`,
3858		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
3859		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
3860		`}`,
3861	}, "")
3862	return s
3863}
3864func (this *DeploymentStrategy) String() string {
3865	if this == nil {
3866		return "nil"
3867	}
3868	s := strings.Join([]string{`&DeploymentStrategy{`,
3869		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
3870		`RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
3871		`}`,
3872	}, "")
3873	return s
3874}
3875func (this *FSGroupStrategyOptions) String() string {
3876	if this == nil {
3877		return "nil"
3878	}
3879	s := strings.Join([]string{`&FSGroupStrategyOptions{`,
3880		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
3881		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
3882		`}`,
3883	}, "")
3884	return s
3885}
3886func (this *HTTPIngressPath) String() string {
3887	if this == nil {
3888		return "nil"
3889	}
3890	s := strings.Join([]string{`&HTTPIngressPath{`,
3891		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
3892		`Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`,
3893		`}`,
3894	}, "")
3895	return s
3896}
3897func (this *HTTPIngressRuleValue) String() string {
3898	if this == nil {
3899		return "nil"
3900	}
3901	s := strings.Join([]string{`&HTTPIngressRuleValue{`,
3902		`Paths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Paths), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + `,`,
3903		`}`,
3904	}, "")
3905	return s
3906}
3907func (this *HostPortRange) String() string {
3908	if this == nil {
3909		return "nil"
3910	}
3911	s := strings.Join([]string{`&HostPortRange{`,
3912		`Min:` + fmt.Sprintf("%v", this.Min) + `,`,
3913		`Max:` + fmt.Sprintf("%v", this.Max) + `,`,
3914		`}`,
3915	}, "")
3916	return s
3917}
3918func (this *IDRange) String() string {
3919	if this == nil {
3920		return "nil"
3921	}
3922	s := strings.Join([]string{`&IDRange{`,
3923		`Min:` + fmt.Sprintf("%v", this.Min) + `,`,
3924		`Max:` + fmt.Sprintf("%v", this.Max) + `,`,
3925		`}`,
3926	}, "")
3927	return s
3928}
3929func (this *IPBlock) String() string {
3930	if this == nil {
3931		return "nil"
3932	}
3933	s := strings.Join([]string{`&IPBlock{`,
3934		`CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`,
3935		`Except:` + fmt.Sprintf("%v", this.Except) + `,`,
3936		`}`,
3937	}, "")
3938	return s
3939}
3940func (this *Ingress) String() string {
3941	if this == nil {
3942		return "nil"
3943	}
3944	s := strings.Join([]string{`&Ingress{`,
3945		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
3946		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`,
3947		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`,
3948		`}`,
3949	}, "")
3950	return s
3951}
3952func (this *IngressBackend) String() string {
3953	if this == nil {
3954		return "nil"
3955	}
3956	s := strings.Join([]string{`&IngressBackend{`,
3957		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
3958		`ServicePort:` + strings.Replace(strings.Replace(this.ServicePort.String(), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1), `&`, ``, 1) + `,`,
3959		`}`,
3960	}, "")
3961	return s
3962}
3963func (this *IngressList) String() string {
3964	if this == nil {
3965		return "nil"
3966	}
3967	s := strings.Join([]string{`&IngressList{`,
3968		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
3969		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Ingress", "Ingress", 1), `&`, ``, 1) + `,`,
3970		`}`,
3971	}, "")
3972	return s
3973}
3974func (this *IngressRule) String() string {
3975	if this == nil {
3976		return "nil"
3977	}
3978	s := strings.Join([]string{`&IngressRule{`,
3979		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
3980		`IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`,
3981		`}`,
3982	}, "")
3983	return s
3984}
3985func (this *IngressRuleValue) String() string {
3986	if this == nil {
3987		return "nil"
3988	}
3989	s := strings.Join([]string{`&IngressRuleValue{`,
3990		`HTTP:` + strings.Replace(fmt.Sprintf("%v", this.HTTP), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`,
3991		`}`,
3992	}, "")
3993	return s
3994}
3995func (this *IngressSpec) String() string {
3996	if this == nil {
3997		return "nil"
3998	}
3999	s := strings.Join([]string{`&IngressSpec{`,
4000		`Backend:` + strings.Replace(fmt.Sprintf("%v", this.Backend), "IngressBackend", "IngressBackend", 1) + `,`,
4001		`TLS:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TLS), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + `,`,
4002		`Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "IngressRule", "IngressRule", 1), `&`, ``, 1) + `,`,
4003		`}`,
4004	}, "")
4005	return s
4006}
4007func (this *IngressStatus) String() string {
4008	if this == nil {
4009		return "nil"
4010	}
4011	s := strings.Join([]string{`&IngressStatus{`,
4012		`LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "LoadBalancerStatus", "k8s_io_api_core_v1.LoadBalancerStatus", 1), `&`, ``, 1) + `,`,
4013		`}`,
4014	}, "")
4015	return s
4016}
4017func (this *IngressTLS) String() string {
4018	if this == nil {
4019		return "nil"
4020	}
4021	s := strings.Join([]string{`&IngressTLS{`,
4022		`Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`,
4023		`SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`,
4024		`}`,
4025	}, "")
4026	return s
4027}
4028func (this *NetworkPolicy) String() string {
4029	if this == nil {
4030		return "nil"
4031	}
4032	s := strings.Join([]string{`&NetworkPolicy{`,
4033		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4034		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`,
4035		`}`,
4036	}, "")
4037	return s
4038}
4039func (this *NetworkPolicyEgressRule) String() string {
4040	if this == nil {
4041		return "nil"
4042	}
4043	s := strings.Join([]string{`&NetworkPolicyEgressRule{`,
4044		`Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
4045		`To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
4046		`}`,
4047	}, "")
4048	return s
4049}
4050func (this *NetworkPolicyIngressRule) String() string {
4051	if this == nil {
4052		return "nil"
4053	}
4054	s := strings.Join([]string{`&NetworkPolicyIngressRule{`,
4055		`Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`,
4056		`From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`,
4057		`}`,
4058	}, "")
4059	return s
4060}
4061func (this *NetworkPolicyList) String() string {
4062	if this == nil {
4063		return "nil"
4064	}
4065	s := strings.Join([]string{`&NetworkPolicyList{`,
4066		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4067		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + `,`,
4068		`}`,
4069	}, "")
4070	return s
4071}
4072func (this *NetworkPolicyPeer) String() string {
4073	if this == nil {
4074		return "nil"
4075	}
4076	s := strings.Join([]string{`&NetworkPolicyPeer{`,
4077		`PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4078		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4079		`IPBlock:` + strings.Replace(fmt.Sprintf("%v", this.IPBlock), "IPBlock", "IPBlock", 1) + `,`,
4080		`}`,
4081	}, "")
4082	return s
4083}
4084func (this *NetworkPolicyPort) String() string {
4085	if this == nil {
4086		return "nil"
4087	}
4088	s := strings.Join([]string{`&NetworkPolicyPort{`,
4089		`Protocol:` + valueToStringGenerated(this.Protocol) + `,`,
4090		`Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4091		`}`,
4092	}, "")
4093	return s
4094}
4095func (this *NetworkPolicySpec) String() string {
4096	if this == nil {
4097		return "nil"
4098	}
4099	s := strings.Join([]string{`&NetworkPolicySpec{`,
4100		`PodSelector:` + strings.Replace(strings.Replace(this.PodSelector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`,
4101		`Ingress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ingress), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + `,`,
4102		`Egress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Egress), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + `,`,
4103		`PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`,
4104		`}`,
4105	}, "")
4106	return s
4107}
4108func (this *PodSecurityPolicy) String() string {
4109	if this == nil {
4110		return "nil"
4111	}
4112	s := strings.Join([]string{`&PodSecurityPolicy{`,
4113		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4114		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`,
4115		`}`,
4116	}, "")
4117	return s
4118}
4119func (this *PodSecurityPolicyList) String() string {
4120	if this == nil {
4121		return "nil"
4122	}
4123	s := strings.Join([]string{`&PodSecurityPolicyList{`,
4124		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4125		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`,
4126		`}`,
4127	}, "")
4128	return s
4129}
4130func (this *PodSecurityPolicySpec) String() string {
4131	if this == nil {
4132		return "nil"
4133	}
4134	s := strings.Join([]string{`&PodSecurityPolicySpec{`,
4135		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
4136		`DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`,
4137		`RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`,
4138		`AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`,
4139		`Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`,
4140		`HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`,
4141		`HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`,
4142		`HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`,
4143		`HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`,
4144		`SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`,
4145		`RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`,
4146		`SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`,
4147		`FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`,
4148		`ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`,
4149		`DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`,
4150		`AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`,
4151		`AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`,
4152		`AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`,
4153		`AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`,
4154		`ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`,
4155		`AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`,
4156		`RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`,
4157		`AllowedCSIDrivers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedCSIDrivers), "AllowedCSIDriver", "AllowedCSIDriver", 1), `&`, ``, 1) + `,`,
4158		`}`,
4159	}, "")
4160	return s
4161}
4162func (this *ReplicaSet) String() string {
4163	if this == nil {
4164		return "nil"
4165	}
4166	s := strings.Join([]string{`&ReplicaSet{`,
4167		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4168		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
4169		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
4170		`}`,
4171	}, "")
4172	return s
4173}
4174func (this *ReplicaSetCondition) String() string {
4175	if this == nil {
4176		return "nil"
4177	}
4178	s := strings.Join([]string{`&ReplicaSetCondition{`,
4179		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
4180		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
4181		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
4182		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
4183		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
4184		`}`,
4185	}, "")
4186	return s
4187}
4188func (this *ReplicaSetList) String() string {
4189	if this == nil {
4190		return "nil"
4191	}
4192	s := strings.Join([]string{`&ReplicaSetList{`,
4193		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
4194		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`,
4195		`}`,
4196	}, "")
4197	return s
4198}
4199func (this *ReplicaSetSpec) String() string {
4200	if this == nil {
4201		return "nil"
4202	}
4203	s := strings.Join([]string{`&ReplicaSetSpec{`,
4204		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
4205		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
4206		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
4207		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
4208		`}`,
4209	}, "")
4210	return s
4211}
4212func (this *ReplicaSetStatus) String() string {
4213	if this == nil {
4214		return "nil"
4215	}
4216	s := strings.Join([]string{`&ReplicaSetStatus{`,
4217		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4218		`FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
4219		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
4220		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
4221		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
4222		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`,
4223		`}`,
4224	}, "")
4225	return s
4226}
4227func (this *ReplicationControllerDummy) String() string {
4228	if this == nil {
4229		return "nil"
4230	}
4231	s := strings.Join([]string{`&ReplicationControllerDummy{`,
4232		`}`,
4233	}, "")
4234	return s
4235}
4236func (this *RollbackConfig) String() string {
4237	if this == nil {
4238		return "nil"
4239	}
4240	s := strings.Join([]string{`&RollbackConfig{`,
4241		`Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
4242		`}`,
4243	}, "")
4244	return s
4245}
4246func (this *RollingUpdateDaemonSet) String() string {
4247	if this == nil {
4248		return "nil"
4249	}
4250	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
4251		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4252		`}`,
4253	}, "")
4254	return s
4255}
4256func (this *RollingUpdateDeployment) String() string {
4257	if this == nil {
4258		return "nil"
4259	}
4260	s := strings.Join([]string{`&RollingUpdateDeployment{`,
4261		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4262		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
4263		`}`,
4264	}, "")
4265	return s
4266}
4267func (this *RunAsGroupStrategyOptions) String() string {
4268	if this == nil {
4269		return "nil"
4270	}
4271	s := strings.Join([]string{`&RunAsGroupStrategyOptions{`,
4272		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4273		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4274		`}`,
4275	}, "")
4276	return s
4277}
4278func (this *RunAsUserStrategyOptions) String() string {
4279	if this == nil {
4280		return "nil"
4281	}
4282	s := strings.Join([]string{`&RunAsUserStrategyOptions{`,
4283		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4284		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4285		`}`,
4286	}, "")
4287	return s
4288}
4289func (this *SELinuxStrategyOptions) String() string {
4290	if this == nil {
4291		return "nil"
4292	}
4293	s := strings.Join([]string{`&SELinuxStrategyOptions{`,
4294		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4295		`SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`,
4296		`}`,
4297	}, "")
4298	return s
4299}
4300func (this *Scale) String() string {
4301	if this == nil {
4302		return "nil"
4303	}
4304	s := strings.Join([]string{`&Scale{`,
4305		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
4306		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
4307		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
4308		`}`,
4309	}, "")
4310	return s
4311}
4312func (this *ScaleSpec) String() string {
4313	if this == nil {
4314		return "nil"
4315	}
4316	s := strings.Join([]string{`&ScaleSpec{`,
4317		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4318		`}`,
4319	}, "")
4320	return s
4321}
4322func (this *ScaleStatus) String() string {
4323	if this == nil {
4324		return "nil"
4325	}
4326	keysForSelector := make([]string, 0, len(this.Selector))
4327	for k := range this.Selector {
4328		keysForSelector = append(keysForSelector, k)
4329	}
4330	github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
4331	mapStringForSelector := "map[string]string{"
4332	for _, k := range keysForSelector {
4333		mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
4334	}
4335	mapStringForSelector += "}"
4336	s := strings.Join([]string{`&ScaleStatus{`,
4337		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
4338		`Selector:` + mapStringForSelector + `,`,
4339		`TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
4340		`}`,
4341	}, "")
4342	return s
4343}
4344func (this *SupplementalGroupsStrategyOptions) String() string {
4345	if this == nil {
4346		return "nil"
4347	}
4348	s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`,
4349		`Rule:` + fmt.Sprintf("%v", this.Rule) + `,`,
4350		`Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`,
4351		`}`,
4352	}, "")
4353	return s
4354}
4355func valueToStringGenerated(v interface{}) string {
4356	rv := reflect.ValueOf(v)
4357	if rv.IsNil() {
4358		return "nil"
4359	}
4360	pv := reflect.Indirect(rv).Interface()
4361	return fmt.Sprintf("*%v", pv)
4362}
4363func (m *AllowedCSIDriver) Unmarshal(dAtA []byte) error {
4364	l := len(dAtA)
4365	iNdEx := 0
4366	for iNdEx < l {
4367		preIndex := iNdEx
4368		var wire uint64
4369		for shift := uint(0); ; shift += 7 {
4370			if shift >= 64 {
4371				return ErrIntOverflowGenerated
4372			}
4373			if iNdEx >= l {
4374				return io.ErrUnexpectedEOF
4375			}
4376			b := dAtA[iNdEx]
4377			iNdEx++
4378			wire |= (uint64(b) & 0x7F) << shift
4379			if b < 0x80 {
4380				break
4381			}
4382		}
4383		fieldNum := int32(wire >> 3)
4384		wireType := int(wire & 0x7)
4385		if wireType == 4 {
4386			return fmt.Errorf("proto: AllowedCSIDriver: wiretype end group for non-group")
4387		}
4388		if fieldNum <= 0 {
4389			return fmt.Errorf("proto: AllowedCSIDriver: illegal tag %d (wire type %d)", fieldNum, wire)
4390		}
4391		switch fieldNum {
4392		case 1:
4393			if wireType != 2 {
4394				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4395			}
4396			var stringLen uint64
4397			for shift := uint(0); ; shift += 7 {
4398				if shift >= 64 {
4399					return ErrIntOverflowGenerated
4400				}
4401				if iNdEx >= l {
4402					return io.ErrUnexpectedEOF
4403				}
4404				b := dAtA[iNdEx]
4405				iNdEx++
4406				stringLen |= (uint64(b) & 0x7F) << shift
4407				if b < 0x80 {
4408					break
4409				}
4410			}
4411			intStringLen := int(stringLen)
4412			if intStringLen < 0 {
4413				return ErrInvalidLengthGenerated
4414			}
4415			postIndex := iNdEx + intStringLen
4416			if postIndex > l {
4417				return io.ErrUnexpectedEOF
4418			}
4419			m.Name = string(dAtA[iNdEx:postIndex])
4420			iNdEx = postIndex
4421		default:
4422			iNdEx = preIndex
4423			skippy, err := skipGenerated(dAtA[iNdEx:])
4424			if err != nil {
4425				return err
4426			}
4427			if skippy < 0 {
4428				return ErrInvalidLengthGenerated
4429			}
4430			if (iNdEx + skippy) > l {
4431				return io.ErrUnexpectedEOF
4432			}
4433			iNdEx += skippy
4434		}
4435	}
4436
4437	if iNdEx > l {
4438		return io.ErrUnexpectedEOF
4439	}
4440	return nil
4441}
4442func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error {
4443	l := len(dAtA)
4444	iNdEx := 0
4445	for iNdEx < l {
4446		preIndex := iNdEx
4447		var wire uint64
4448		for shift := uint(0); ; shift += 7 {
4449			if shift >= 64 {
4450				return ErrIntOverflowGenerated
4451			}
4452			if iNdEx >= l {
4453				return io.ErrUnexpectedEOF
4454			}
4455			b := dAtA[iNdEx]
4456			iNdEx++
4457			wire |= (uint64(b) & 0x7F) << shift
4458			if b < 0x80 {
4459				break
4460			}
4461		}
4462		fieldNum := int32(wire >> 3)
4463		wireType := int(wire & 0x7)
4464		if wireType == 4 {
4465			return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group")
4466		}
4467		if fieldNum <= 0 {
4468			return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire)
4469		}
4470		switch fieldNum {
4471		case 1:
4472			if wireType != 2 {
4473				return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType)
4474			}
4475			var stringLen uint64
4476			for shift := uint(0); ; shift += 7 {
4477				if shift >= 64 {
4478					return ErrIntOverflowGenerated
4479				}
4480				if iNdEx >= l {
4481					return io.ErrUnexpectedEOF
4482				}
4483				b := dAtA[iNdEx]
4484				iNdEx++
4485				stringLen |= (uint64(b) & 0x7F) << shift
4486				if b < 0x80 {
4487					break
4488				}
4489			}
4490			intStringLen := int(stringLen)
4491			if intStringLen < 0 {
4492				return ErrInvalidLengthGenerated
4493			}
4494			postIndex := iNdEx + intStringLen
4495			if postIndex > l {
4496				return io.ErrUnexpectedEOF
4497			}
4498			m.Driver = string(dAtA[iNdEx:postIndex])
4499			iNdEx = postIndex
4500		default:
4501			iNdEx = preIndex
4502			skippy, err := skipGenerated(dAtA[iNdEx:])
4503			if err != nil {
4504				return err
4505			}
4506			if skippy < 0 {
4507				return ErrInvalidLengthGenerated
4508			}
4509			if (iNdEx + skippy) > l {
4510				return io.ErrUnexpectedEOF
4511			}
4512			iNdEx += skippy
4513		}
4514	}
4515
4516	if iNdEx > l {
4517		return io.ErrUnexpectedEOF
4518	}
4519	return nil
4520}
4521func (m *AllowedHostPath) Unmarshal(dAtA []byte) error {
4522	l := len(dAtA)
4523	iNdEx := 0
4524	for iNdEx < l {
4525		preIndex := iNdEx
4526		var wire uint64
4527		for shift := uint(0); ; shift += 7 {
4528			if shift >= 64 {
4529				return ErrIntOverflowGenerated
4530			}
4531			if iNdEx >= l {
4532				return io.ErrUnexpectedEOF
4533			}
4534			b := dAtA[iNdEx]
4535			iNdEx++
4536			wire |= (uint64(b) & 0x7F) << shift
4537			if b < 0x80 {
4538				break
4539			}
4540		}
4541		fieldNum := int32(wire >> 3)
4542		wireType := int(wire & 0x7)
4543		if wireType == 4 {
4544			return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group")
4545		}
4546		if fieldNum <= 0 {
4547			return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire)
4548		}
4549		switch fieldNum {
4550		case 1:
4551			if wireType != 2 {
4552				return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)
4553			}
4554			var stringLen uint64
4555			for shift := uint(0); ; shift += 7 {
4556				if shift >= 64 {
4557					return ErrIntOverflowGenerated
4558				}
4559				if iNdEx >= l {
4560					return io.ErrUnexpectedEOF
4561				}
4562				b := dAtA[iNdEx]
4563				iNdEx++
4564				stringLen |= (uint64(b) & 0x7F) << shift
4565				if b < 0x80 {
4566					break
4567				}
4568			}
4569			intStringLen := int(stringLen)
4570			if intStringLen < 0 {
4571				return ErrInvalidLengthGenerated
4572			}
4573			postIndex := iNdEx + intStringLen
4574			if postIndex > l {
4575				return io.ErrUnexpectedEOF
4576			}
4577			m.PathPrefix = string(dAtA[iNdEx:postIndex])
4578			iNdEx = postIndex
4579		case 2:
4580			if wireType != 0 {
4581				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
4582			}
4583			var v int
4584			for shift := uint(0); ; shift += 7 {
4585				if shift >= 64 {
4586					return ErrIntOverflowGenerated
4587				}
4588				if iNdEx >= l {
4589					return io.ErrUnexpectedEOF
4590				}
4591				b := dAtA[iNdEx]
4592				iNdEx++
4593				v |= (int(b) & 0x7F) << shift
4594				if b < 0x80 {
4595					break
4596				}
4597			}
4598			m.ReadOnly = bool(v != 0)
4599		default:
4600			iNdEx = preIndex
4601			skippy, err := skipGenerated(dAtA[iNdEx:])
4602			if err != nil {
4603				return err
4604			}
4605			if skippy < 0 {
4606				return ErrInvalidLengthGenerated
4607			}
4608			if (iNdEx + skippy) > l {
4609				return io.ErrUnexpectedEOF
4610			}
4611			iNdEx += skippy
4612		}
4613	}
4614
4615	if iNdEx > l {
4616		return io.ErrUnexpectedEOF
4617	}
4618	return nil
4619}
4620func (m *DaemonSet) Unmarshal(dAtA []byte) error {
4621	l := len(dAtA)
4622	iNdEx := 0
4623	for iNdEx < l {
4624		preIndex := iNdEx
4625		var wire uint64
4626		for shift := uint(0); ; shift += 7 {
4627			if shift >= 64 {
4628				return ErrIntOverflowGenerated
4629			}
4630			if iNdEx >= l {
4631				return io.ErrUnexpectedEOF
4632			}
4633			b := dAtA[iNdEx]
4634			iNdEx++
4635			wire |= (uint64(b) & 0x7F) << shift
4636			if b < 0x80 {
4637				break
4638			}
4639		}
4640		fieldNum := int32(wire >> 3)
4641		wireType := int(wire & 0x7)
4642		if wireType == 4 {
4643			return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
4644		}
4645		if fieldNum <= 0 {
4646			return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
4647		}
4648		switch fieldNum {
4649		case 1:
4650			if wireType != 2 {
4651				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4652			}
4653			var msglen int
4654			for shift := uint(0); ; shift += 7 {
4655				if shift >= 64 {
4656					return ErrIntOverflowGenerated
4657				}
4658				if iNdEx >= l {
4659					return io.ErrUnexpectedEOF
4660				}
4661				b := dAtA[iNdEx]
4662				iNdEx++
4663				msglen |= (int(b) & 0x7F) << shift
4664				if b < 0x80 {
4665					break
4666				}
4667			}
4668			if msglen < 0 {
4669				return ErrInvalidLengthGenerated
4670			}
4671			postIndex := iNdEx + msglen
4672			if postIndex > l {
4673				return io.ErrUnexpectedEOF
4674			}
4675			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4676				return err
4677			}
4678			iNdEx = postIndex
4679		case 2:
4680			if wireType != 2 {
4681				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4682			}
4683			var msglen int
4684			for shift := uint(0); ; shift += 7 {
4685				if shift >= 64 {
4686					return ErrIntOverflowGenerated
4687				}
4688				if iNdEx >= l {
4689					return io.ErrUnexpectedEOF
4690				}
4691				b := dAtA[iNdEx]
4692				iNdEx++
4693				msglen |= (int(b) & 0x7F) << shift
4694				if b < 0x80 {
4695					break
4696				}
4697			}
4698			if msglen < 0 {
4699				return ErrInvalidLengthGenerated
4700			}
4701			postIndex := iNdEx + msglen
4702			if postIndex > l {
4703				return io.ErrUnexpectedEOF
4704			}
4705			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4706				return err
4707			}
4708			iNdEx = postIndex
4709		case 3:
4710			if wireType != 2 {
4711				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4712			}
4713			var msglen int
4714			for shift := uint(0); ; shift += 7 {
4715				if shift >= 64 {
4716					return ErrIntOverflowGenerated
4717				}
4718				if iNdEx >= l {
4719					return io.ErrUnexpectedEOF
4720				}
4721				b := dAtA[iNdEx]
4722				iNdEx++
4723				msglen |= (int(b) & 0x7F) << shift
4724				if b < 0x80 {
4725					break
4726				}
4727			}
4728			if msglen < 0 {
4729				return ErrInvalidLengthGenerated
4730			}
4731			postIndex := iNdEx + msglen
4732			if postIndex > l {
4733				return io.ErrUnexpectedEOF
4734			}
4735			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4736				return err
4737			}
4738			iNdEx = postIndex
4739		default:
4740			iNdEx = preIndex
4741			skippy, err := skipGenerated(dAtA[iNdEx:])
4742			if err != nil {
4743				return err
4744			}
4745			if skippy < 0 {
4746				return ErrInvalidLengthGenerated
4747			}
4748			if (iNdEx + skippy) > l {
4749				return io.ErrUnexpectedEOF
4750			}
4751			iNdEx += skippy
4752		}
4753	}
4754
4755	if iNdEx > l {
4756		return io.ErrUnexpectedEOF
4757	}
4758	return nil
4759}
4760func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
4761	l := len(dAtA)
4762	iNdEx := 0
4763	for iNdEx < l {
4764		preIndex := iNdEx
4765		var wire uint64
4766		for shift := uint(0); ; shift += 7 {
4767			if shift >= 64 {
4768				return ErrIntOverflowGenerated
4769			}
4770			if iNdEx >= l {
4771				return io.ErrUnexpectedEOF
4772			}
4773			b := dAtA[iNdEx]
4774			iNdEx++
4775			wire |= (uint64(b) & 0x7F) << shift
4776			if b < 0x80 {
4777				break
4778			}
4779		}
4780		fieldNum := int32(wire >> 3)
4781		wireType := int(wire & 0x7)
4782		if wireType == 4 {
4783			return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
4784		}
4785		if fieldNum <= 0 {
4786			return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4787		}
4788		switch fieldNum {
4789		case 1:
4790			if wireType != 2 {
4791				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4792			}
4793			var stringLen uint64
4794			for shift := uint(0); ; shift += 7 {
4795				if shift >= 64 {
4796					return ErrIntOverflowGenerated
4797				}
4798				if iNdEx >= l {
4799					return io.ErrUnexpectedEOF
4800				}
4801				b := dAtA[iNdEx]
4802				iNdEx++
4803				stringLen |= (uint64(b) & 0x7F) << shift
4804				if b < 0x80 {
4805					break
4806				}
4807			}
4808			intStringLen := int(stringLen)
4809			if intStringLen < 0 {
4810				return ErrInvalidLengthGenerated
4811			}
4812			postIndex := iNdEx + intStringLen
4813			if postIndex > l {
4814				return io.ErrUnexpectedEOF
4815			}
4816			m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
4817			iNdEx = postIndex
4818		case 2:
4819			if wireType != 2 {
4820				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4821			}
4822			var stringLen uint64
4823			for shift := uint(0); ; shift += 7 {
4824				if shift >= 64 {
4825					return ErrIntOverflowGenerated
4826				}
4827				if iNdEx >= l {
4828					return io.ErrUnexpectedEOF
4829				}
4830				b := dAtA[iNdEx]
4831				iNdEx++
4832				stringLen |= (uint64(b) & 0x7F) << shift
4833				if b < 0x80 {
4834					break
4835				}
4836			}
4837			intStringLen := int(stringLen)
4838			if intStringLen < 0 {
4839				return ErrInvalidLengthGenerated
4840			}
4841			postIndex := iNdEx + intStringLen
4842			if postIndex > l {
4843				return io.ErrUnexpectedEOF
4844			}
4845			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4846			iNdEx = postIndex
4847		case 3:
4848			if wireType != 2 {
4849				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4850			}
4851			var msglen int
4852			for shift := uint(0); ; shift += 7 {
4853				if shift >= 64 {
4854					return ErrIntOverflowGenerated
4855				}
4856				if iNdEx >= l {
4857					return io.ErrUnexpectedEOF
4858				}
4859				b := dAtA[iNdEx]
4860				iNdEx++
4861				msglen |= (int(b) & 0x7F) << shift
4862				if b < 0x80 {
4863					break
4864				}
4865			}
4866			if msglen < 0 {
4867				return ErrInvalidLengthGenerated
4868			}
4869			postIndex := iNdEx + msglen
4870			if postIndex > l {
4871				return io.ErrUnexpectedEOF
4872			}
4873			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4874				return err
4875			}
4876			iNdEx = postIndex
4877		case 4:
4878			if wireType != 2 {
4879				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4880			}
4881			var stringLen uint64
4882			for shift := uint(0); ; shift += 7 {
4883				if shift >= 64 {
4884					return ErrIntOverflowGenerated
4885				}
4886				if iNdEx >= l {
4887					return io.ErrUnexpectedEOF
4888				}
4889				b := dAtA[iNdEx]
4890				iNdEx++
4891				stringLen |= (uint64(b) & 0x7F) << shift
4892				if b < 0x80 {
4893					break
4894				}
4895			}
4896			intStringLen := int(stringLen)
4897			if intStringLen < 0 {
4898				return ErrInvalidLengthGenerated
4899			}
4900			postIndex := iNdEx + intStringLen
4901			if postIndex > l {
4902				return io.ErrUnexpectedEOF
4903			}
4904			m.Reason = string(dAtA[iNdEx:postIndex])
4905			iNdEx = postIndex
4906		case 5:
4907			if wireType != 2 {
4908				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4909			}
4910			var stringLen uint64
4911			for shift := uint(0); ; shift += 7 {
4912				if shift >= 64 {
4913					return ErrIntOverflowGenerated
4914				}
4915				if iNdEx >= l {
4916					return io.ErrUnexpectedEOF
4917				}
4918				b := dAtA[iNdEx]
4919				iNdEx++
4920				stringLen |= (uint64(b) & 0x7F) << shift
4921				if b < 0x80 {
4922					break
4923				}
4924			}
4925			intStringLen := int(stringLen)
4926			if intStringLen < 0 {
4927				return ErrInvalidLengthGenerated
4928			}
4929			postIndex := iNdEx + intStringLen
4930			if postIndex > l {
4931				return io.ErrUnexpectedEOF
4932			}
4933			m.Message = string(dAtA[iNdEx:postIndex])
4934			iNdEx = postIndex
4935		default:
4936			iNdEx = preIndex
4937			skippy, err := skipGenerated(dAtA[iNdEx:])
4938			if err != nil {
4939				return err
4940			}
4941			if skippy < 0 {
4942				return ErrInvalidLengthGenerated
4943			}
4944			if (iNdEx + skippy) > l {
4945				return io.ErrUnexpectedEOF
4946			}
4947			iNdEx += skippy
4948		}
4949	}
4950
4951	if iNdEx > l {
4952		return io.ErrUnexpectedEOF
4953	}
4954	return nil
4955}
4956func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
4957	l := len(dAtA)
4958	iNdEx := 0
4959	for iNdEx < l {
4960		preIndex := iNdEx
4961		var wire uint64
4962		for shift := uint(0); ; shift += 7 {
4963			if shift >= 64 {
4964				return ErrIntOverflowGenerated
4965			}
4966			if iNdEx >= l {
4967				return io.ErrUnexpectedEOF
4968			}
4969			b := dAtA[iNdEx]
4970			iNdEx++
4971			wire |= (uint64(b) & 0x7F) << shift
4972			if b < 0x80 {
4973				break
4974			}
4975		}
4976		fieldNum := int32(wire >> 3)
4977		wireType := int(wire & 0x7)
4978		if wireType == 4 {
4979			return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
4980		}
4981		if fieldNum <= 0 {
4982			return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
4983		}
4984		switch fieldNum {
4985		case 1:
4986			if wireType != 2 {
4987				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4988			}
4989			var msglen int
4990			for shift := uint(0); ; shift += 7 {
4991				if shift >= 64 {
4992					return ErrIntOverflowGenerated
4993				}
4994				if iNdEx >= l {
4995					return io.ErrUnexpectedEOF
4996				}
4997				b := dAtA[iNdEx]
4998				iNdEx++
4999				msglen |= (int(b) & 0x7F) << shift
5000				if b < 0x80 {
5001					break
5002				}
5003			}
5004			if msglen < 0 {
5005				return ErrInvalidLengthGenerated
5006			}
5007			postIndex := iNdEx + msglen
5008			if postIndex > l {
5009				return io.ErrUnexpectedEOF
5010			}
5011			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5012				return err
5013			}
5014			iNdEx = postIndex
5015		case 2:
5016			if wireType != 2 {
5017				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5018			}
5019			var msglen int
5020			for shift := uint(0); ; shift += 7 {
5021				if shift >= 64 {
5022					return ErrIntOverflowGenerated
5023				}
5024				if iNdEx >= l {
5025					return io.ErrUnexpectedEOF
5026				}
5027				b := dAtA[iNdEx]
5028				iNdEx++
5029				msglen |= (int(b) & 0x7F) << shift
5030				if b < 0x80 {
5031					break
5032				}
5033			}
5034			if msglen < 0 {
5035				return ErrInvalidLengthGenerated
5036			}
5037			postIndex := iNdEx + msglen
5038			if postIndex > l {
5039				return io.ErrUnexpectedEOF
5040			}
5041			m.Items = append(m.Items, DaemonSet{})
5042			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5043				return err
5044			}
5045			iNdEx = postIndex
5046		default:
5047			iNdEx = preIndex
5048			skippy, err := skipGenerated(dAtA[iNdEx:])
5049			if err != nil {
5050				return err
5051			}
5052			if skippy < 0 {
5053				return ErrInvalidLengthGenerated
5054			}
5055			if (iNdEx + skippy) > l {
5056				return io.ErrUnexpectedEOF
5057			}
5058			iNdEx += skippy
5059		}
5060	}
5061
5062	if iNdEx > l {
5063		return io.ErrUnexpectedEOF
5064	}
5065	return nil
5066}
5067func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
5068	l := len(dAtA)
5069	iNdEx := 0
5070	for iNdEx < l {
5071		preIndex := iNdEx
5072		var wire uint64
5073		for shift := uint(0); ; shift += 7 {
5074			if shift >= 64 {
5075				return ErrIntOverflowGenerated
5076			}
5077			if iNdEx >= l {
5078				return io.ErrUnexpectedEOF
5079			}
5080			b := dAtA[iNdEx]
5081			iNdEx++
5082			wire |= (uint64(b) & 0x7F) << shift
5083			if b < 0x80 {
5084				break
5085			}
5086		}
5087		fieldNum := int32(wire >> 3)
5088		wireType := int(wire & 0x7)
5089		if wireType == 4 {
5090			return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
5091		}
5092		if fieldNum <= 0 {
5093			return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5094		}
5095		switch fieldNum {
5096		case 1:
5097			if wireType != 2 {
5098				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5099			}
5100			var msglen int
5101			for shift := uint(0); ; shift += 7 {
5102				if shift >= 64 {
5103					return ErrIntOverflowGenerated
5104				}
5105				if iNdEx >= l {
5106					return io.ErrUnexpectedEOF
5107				}
5108				b := dAtA[iNdEx]
5109				iNdEx++
5110				msglen |= (int(b) & 0x7F) << shift
5111				if b < 0x80 {
5112					break
5113				}
5114			}
5115			if msglen < 0 {
5116				return ErrInvalidLengthGenerated
5117			}
5118			postIndex := iNdEx + msglen
5119			if postIndex > l {
5120				return io.ErrUnexpectedEOF
5121			}
5122			if m.Selector == nil {
5123				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
5124			}
5125			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5126				return err
5127			}
5128			iNdEx = postIndex
5129		case 2:
5130			if wireType != 2 {
5131				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
5132			}
5133			var msglen int
5134			for shift := uint(0); ; shift += 7 {
5135				if shift >= 64 {
5136					return ErrIntOverflowGenerated
5137				}
5138				if iNdEx >= l {
5139					return io.ErrUnexpectedEOF
5140				}
5141				b := dAtA[iNdEx]
5142				iNdEx++
5143				msglen |= (int(b) & 0x7F) << shift
5144				if b < 0x80 {
5145					break
5146				}
5147			}
5148			if msglen < 0 {
5149				return ErrInvalidLengthGenerated
5150			}
5151			postIndex := iNdEx + msglen
5152			if postIndex > l {
5153				return io.ErrUnexpectedEOF
5154			}
5155			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5156				return err
5157			}
5158			iNdEx = postIndex
5159		case 3:
5160			if wireType != 2 {
5161				return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
5162			}
5163			var msglen int
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				msglen |= (int(b) & 0x7F) << shift
5174				if b < 0x80 {
5175					break
5176				}
5177			}
5178			if msglen < 0 {
5179				return ErrInvalidLengthGenerated
5180			}
5181			postIndex := iNdEx + msglen
5182			if postIndex > l {
5183				return io.ErrUnexpectedEOF
5184			}
5185			if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5186				return err
5187			}
5188			iNdEx = postIndex
5189		case 4:
5190			if wireType != 0 {
5191				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
5192			}
5193			m.MinReadySeconds = 0
5194			for shift := uint(0); ; shift += 7 {
5195				if shift >= 64 {
5196					return ErrIntOverflowGenerated
5197				}
5198				if iNdEx >= l {
5199					return io.ErrUnexpectedEOF
5200				}
5201				b := dAtA[iNdEx]
5202				iNdEx++
5203				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
5204				if b < 0x80 {
5205					break
5206				}
5207			}
5208		case 5:
5209			if wireType != 0 {
5210				return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType)
5211			}
5212			m.TemplateGeneration = 0
5213			for shift := uint(0); ; shift += 7 {
5214				if shift >= 64 {
5215					return ErrIntOverflowGenerated
5216				}
5217				if iNdEx >= l {
5218					return io.ErrUnexpectedEOF
5219				}
5220				b := dAtA[iNdEx]
5221				iNdEx++
5222				m.TemplateGeneration |= (int64(b) & 0x7F) << shift
5223				if b < 0x80 {
5224					break
5225				}
5226			}
5227		case 6:
5228			if wireType != 0 {
5229				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
5230			}
5231			var v int32
5232			for shift := uint(0); ; shift += 7 {
5233				if shift >= 64 {
5234					return ErrIntOverflowGenerated
5235				}
5236				if iNdEx >= l {
5237					return io.ErrUnexpectedEOF
5238				}
5239				b := dAtA[iNdEx]
5240				iNdEx++
5241				v |= (int32(b) & 0x7F) << shift
5242				if b < 0x80 {
5243					break
5244				}
5245			}
5246			m.RevisionHistoryLimit = &v
5247		default:
5248			iNdEx = preIndex
5249			skippy, err := skipGenerated(dAtA[iNdEx:])
5250			if err != nil {
5251				return err
5252			}
5253			if skippy < 0 {
5254				return ErrInvalidLengthGenerated
5255			}
5256			if (iNdEx + skippy) > l {
5257				return io.ErrUnexpectedEOF
5258			}
5259			iNdEx += skippy
5260		}
5261	}
5262
5263	if iNdEx > l {
5264		return io.ErrUnexpectedEOF
5265	}
5266	return nil
5267}
5268func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
5269	l := len(dAtA)
5270	iNdEx := 0
5271	for iNdEx < l {
5272		preIndex := iNdEx
5273		var wire uint64
5274		for shift := uint(0); ; shift += 7 {
5275			if shift >= 64 {
5276				return ErrIntOverflowGenerated
5277			}
5278			if iNdEx >= l {
5279				return io.ErrUnexpectedEOF
5280			}
5281			b := dAtA[iNdEx]
5282			iNdEx++
5283			wire |= (uint64(b) & 0x7F) << shift
5284			if b < 0x80 {
5285				break
5286			}
5287		}
5288		fieldNum := int32(wire >> 3)
5289		wireType := int(wire & 0x7)
5290		if wireType == 4 {
5291			return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
5292		}
5293		if fieldNum <= 0 {
5294			return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5295		}
5296		switch fieldNum {
5297		case 1:
5298			if wireType != 0 {
5299				return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
5300			}
5301			m.CurrentNumberScheduled = 0
5302			for shift := uint(0); ; shift += 7 {
5303				if shift >= 64 {
5304					return ErrIntOverflowGenerated
5305				}
5306				if iNdEx >= l {
5307					return io.ErrUnexpectedEOF
5308				}
5309				b := dAtA[iNdEx]
5310				iNdEx++
5311				m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift
5312				if b < 0x80 {
5313					break
5314				}
5315			}
5316		case 2:
5317			if wireType != 0 {
5318				return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
5319			}
5320			m.NumberMisscheduled = 0
5321			for shift := uint(0); ; shift += 7 {
5322				if shift >= 64 {
5323					return ErrIntOverflowGenerated
5324				}
5325				if iNdEx >= l {
5326					return io.ErrUnexpectedEOF
5327				}
5328				b := dAtA[iNdEx]
5329				iNdEx++
5330				m.NumberMisscheduled |= (int32(b) & 0x7F) << shift
5331				if b < 0x80 {
5332					break
5333				}
5334			}
5335		case 3:
5336			if wireType != 0 {
5337				return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
5338			}
5339			m.DesiredNumberScheduled = 0
5340			for shift := uint(0); ; shift += 7 {
5341				if shift >= 64 {
5342					return ErrIntOverflowGenerated
5343				}
5344				if iNdEx >= l {
5345					return io.ErrUnexpectedEOF
5346				}
5347				b := dAtA[iNdEx]
5348				iNdEx++
5349				m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift
5350				if b < 0x80 {
5351					break
5352				}
5353			}
5354		case 4:
5355			if wireType != 0 {
5356				return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
5357			}
5358			m.NumberReady = 0
5359			for shift := uint(0); ; shift += 7 {
5360				if shift >= 64 {
5361					return ErrIntOverflowGenerated
5362				}
5363				if iNdEx >= l {
5364					return io.ErrUnexpectedEOF
5365				}
5366				b := dAtA[iNdEx]
5367				iNdEx++
5368				m.NumberReady |= (int32(b) & 0x7F) << shift
5369				if b < 0x80 {
5370					break
5371				}
5372			}
5373		case 5:
5374			if wireType != 0 {
5375				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
5376			}
5377			m.ObservedGeneration = 0
5378			for shift := uint(0); ; shift += 7 {
5379				if shift >= 64 {
5380					return ErrIntOverflowGenerated
5381				}
5382				if iNdEx >= l {
5383					return io.ErrUnexpectedEOF
5384				}
5385				b := dAtA[iNdEx]
5386				iNdEx++
5387				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
5388				if b < 0x80 {
5389					break
5390				}
5391			}
5392		case 6:
5393			if wireType != 0 {
5394				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
5395			}
5396			m.UpdatedNumberScheduled = 0
5397			for shift := uint(0); ; shift += 7 {
5398				if shift >= 64 {
5399					return ErrIntOverflowGenerated
5400				}
5401				if iNdEx >= l {
5402					return io.ErrUnexpectedEOF
5403				}
5404				b := dAtA[iNdEx]
5405				iNdEx++
5406				m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift
5407				if b < 0x80 {
5408					break
5409				}
5410			}
5411		case 7:
5412			if wireType != 0 {
5413				return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
5414			}
5415			m.NumberAvailable = 0
5416			for shift := uint(0); ; shift += 7 {
5417				if shift >= 64 {
5418					return ErrIntOverflowGenerated
5419				}
5420				if iNdEx >= l {
5421					return io.ErrUnexpectedEOF
5422				}
5423				b := dAtA[iNdEx]
5424				iNdEx++
5425				m.NumberAvailable |= (int32(b) & 0x7F) << shift
5426				if b < 0x80 {
5427					break
5428				}
5429			}
5430		case 8:
5431			if wireType != 0 {
5432				return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
5433			}
5434			m.NumberUnavailable = 0
5435			for shift := uint(0); ; shift += 7 {
5436				if shift >= 64 {
5437					return ErrIntOverflowGenerated
5438				}
5439				if iNdEx >= l {
5440					return io.ErrUnexpectedEOF
5441				}
5442				b := dAtA[iNdEx]
5443				iNdEx++
5444				m.NumberUnavailable |= (int32(b) & 0x7F) << shift
5445				if b < 0x80 {
5446					break
5447				}
5448			}
5449		case 9:
5450			if wireType != 0 {
5451				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
5452			}
5453			var v int32
5454			for shift := uint(0); ; shift += 7 {
5455				if shift >= 64 {
5456					return ErrIntOverflowGenerated
5457				}
5458				if iNdEx >= l {
5459					return io.ErrUnexpectedEOF
5460				}
5461				b := dAtA[iNdEx]
5462				iNdEx++
5463				v |= (int32(b) & 0x7F) << shift
5464				if b < 0x80 {
5465					break
5466				}
5467			}
5468			m.CollisionCount = &v
5469		case 10:
5470			if wireType != 2 {
5471				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5472			}
5473			var msglen int
5474			for shift := uint(0); ; shift += 7 {
5475				if shift >= 64 {
5476					return ErrIntOverflowGenerated
5477				}
5478				if iNdEx >= l {
5479					return io.ErrUnexpectedEOF
5480				}
5481				b := dAtA[iNdEx]
5482				iNdEx++
5483				msglen |= (int(b) & 0x7F) << shift
5484				if b < 0x80 {
5485					break
5486				}
5487			}
5488			if msglen < 0 {
5489				return ErrInvalidLengthGenerated
5490			}
5491			postIndex := iNdEx + msglen
5492			if postIndex > l {
5493				return io.ErrUnexpectedEOF
5494			}
5495			m.Conditions = append(m.Conditions, DaemonSetCondition{})
5496			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5497				return err
5498			}
5499			iNdEx = postIndex
5500		default:
5501			iNdEx = preIndex
5502			skippy, err := skipGenerated(dAtA[iNdEx:])
5503			if err != nil {
5504				return err
5505			}
5506			if skippy < 0 {
5507				return ErrInvalidLengthGenerated
5508			}
5509			if (iNdEx + skippy) > l {
5510				return io.ErrUnexpectedEOF
5511			}
5512			iNdEx += skippy
5513		}
5514	}
5515
5516	if iNdEx > l {
5517		return io.ErrUnexpectedEOF
5518	}
5519	return nil
5520}
5521func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
5522	l := len(dAtA)
5523	iNdEx := 0
5524	for iNdEx < l {
5525		preIndex := iNdEx
5526		var wire uint64
5527		for shift := uint(0); ; shift += 7 {
5528			if shift >= 64 {
5529				return ErrIntOverflowGenerated
5530			}
5531			if iNdEx >= l {
5532				return io.ErrUnexpectedEOF
5533			}
5534			b := dAtA[iNdEx]
5535			iNdEx++
5536			wire |= (uint64(b) & 0x7F) << shift
5537			if b < 0x80 {
5538				break
5539			}
5540		}
5541		fieldNum := int32(wire >> 3)
5542		wireType := int(wire & 0x7)
5543		if wireType == 4 {
5544			return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
5545		}
5546		if fieldNum <= 0 {
5547			return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
5548		}
5549		switch fieldNum {
5550		case 1:
5551			if wireType != 2 {
5552				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5553			}
5554			var stringLen uint64
5555			for shift := uint(0); ; shift += 7 {
5556				if shift >= 64 {
5557					return ErrIntOverflowGenerated
5558				}
5559				if iNdEx >= l {
5560					return io.ErrUnexpectedEOF
5561				}
5562				b := dAtA[iNdEx]
5563				iNdEx++
5564				stringLen |= (uint64(b) & 0x7F) << shift
5565				if b < 0x80 {
5566					break
5567				}
5568			}
5569			intStringLen := int(stringLen)
5570			if intStringLen < 0 {
5571				return ErrInvalidLengthGenerated
5572			}
5573			postIndex := iNdEx + intStringLen
5574			if postIndex > l {
5575				return io.ErrUnexpectedEOF
5576			}
5577			m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
5578			iNdEx = postIndex
5579		case 2:
5580			if wireType != 2 {
5581				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
5582			}
5583			var msglen int
5584			for shift := uint(0); ; shift += 7 {
5585				if shift >= 64 {
5586					return ErrIntOverflowGenerated
5587				}
5588				if iNdEx >= l {
5589					return io.ErrUnexpectedEOF
5590				}
5591				b := dAtA[iNdEx]
5592				iNdEx++
5593				msglen |= (int(b) & 0x7F) << shift
5594				if b < 0x80 {
5595					break
5596				}
5597			}
5598			if msglen < 0 {
5599				return ErrInvalidLengthGenerated
5600			}
5601			postIndex := iNdEx + msglen
5602			if postIndex > l {
5603				return io.ErrUnexpectedEOF
5604			}
5605			if m.RollingUpdate == nil {
5606				m.RollingUpdate = &RollingUpdateDaemonSet{}
5607			}
5608			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5609				return err
5610			}
5611			iNdEx = postIndex
5612		default:
5613			iNdEx = preIndex
5614			skippy, err := skipGenerated(dAtA[iNdEx:])
5615			if err != nil {
5616				return err
5617			}
5618			if skippy < 0 {
5619				return ErrInvalidLengthGenerated
5620			}
5621			if (iNdEx + skippy) > l {
5622				return io.ErrUnexpectedEOF
5623			}
5624			iNdEx += skippy
5625		}
5626	}
5627
5628	if iNdEx > l {
5629		return io.ErrUnexpectedEOF
5630	}
5631	return nil
5632}
5633func (m *Deployment) Unmarshal(dAtA []byte) error {
5634	l := len(dAtA)
5635	iNdEx := 0
5636	for iNdEx < l {
5637		preIndex := iNdEx
5638		var wire uint64
5639		for shift := uint(0); ; shift += 7 {
5640			if shift >= 64 {
5641				return ErrIntOverflowGenerated
5642			}
5643			if iNdEx >= l {
5644				return io.ErrUnexpectedEOF
5645			}
5646			b := dAtA[iNdEx]
5647			iNdEx++
5648			wire |= (uint64(b) & 0x7F) << shift
5649			if b < 0x80 {
5650				break
5651			}
5652		}
5653		fieldNum := int32(wire >> 3)
5654		wireType := int(wire & 0x7)
5655		if wireType == 4 {
5656			return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
5657		}
5658		if fieldNum <= 0 {
5659			return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
5660		}
5661		switch fieldNum {
5662		case 1:
5663			if wireType != 2 {
5664				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5665			}
5666			var msglen int
5667			for shift := uint(0); ; shift += 7 {
5668				if shift >= 64 {
5669					return ErrIntOverflowGenerated
5670				}
5671				if iNdEx >= l {
5672					return io.ErrUnexpectedEOF
5673				}
5674				b := dAtA[iNdEx]
5675				iNdEx++
5676				msglen |= (int(b) & 0x7F) << shift
5677				if b < 0x80 {
5678					break
5679				}
5680			}
5681			if msglen < 0 {
5682				return ErrInvalidLengthGenerated
5683			}
5684			postIndex := iNdEx + msglen
5685			if postIndex > l {
5686				return io.ErrUnexpectedEOF
5687			}
5688			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5689				return err
5690			}
5691			iNdEx = postIndex
5692		case 2:
5693			if wireType != 2 {
5694				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5695			}
5696			var msglen int
5697			for shift := uint(0); ; shift += 7 {
5698				if shift >= 64 {
5699					return ErrIntOverflowGenerated
5700				}
5701				if iNdEx >= l {
5702					return io.ErrUnexpectedEOF
5703				}
5704				b := dAtA[iNdEx]
5705				iNdEx++
5706				msglen |= (int(b) & 0x7F) << shift
5707				if b < 0x80 {
5708					break
5709				}
5710			}
5711			if msglen < 0 {
5712				return ErrInvalidLengthGenerated
5713			}
5714			postIndex := iNdEx + msglen
5715			if postIndex > l {
5716				return io.ErrUnexpectedEOF
5717			}
5718			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5719				return err
5720			}
5721			iNdEx = postIndex
5722		case 3:
5723			if wireType != 2 {
5724				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5725			}
5726			var msglen int
5727			for shift := uint(0); ; shift += 7 {
5728				if shift >= 64 {
5729					return ErrIntOverflowGenerated
5730				}
5731				if iNdEx >= l {
5732					return io.ErrUnexpectedEOF
5733				}
5734				b := dAtA[iNdEx]
5735				iNdEx++
5736				msglen |= (int(b) & 0x7F) << shift
5737				if b < 0x80 {
5738					break
5739				}
5740			}
5741			if msglen < 0 {
5742				return ErrInvalidLengthGenerated
5743			}
5744			postIndex := iNdEx + msglen
5745			if postIndex > l {
5746				return io.ErrUnexpectedEOF
5747			}
5748			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5749				return err
5750			}
5751			iNdEx = postIndex
5752		default:
5753			iNdEx = preIndex
5754			skippy, err := skipGenerated(dAtA[iNdEx:])
5755			if err != nil {
5756				return err
5757			}
5758			if skippy < 0 {
5759				return ErrInvalidLengthGenerated
5760			}
5761			if (iNdEx + skippy) > l {
5762				return io.ErrUnexpectedEOF
5763			}
5764			iNdEx += skippy
5765		}
5766	}
5767
5768	if iNdEx > l {
5769		return io.ErrUnexpectedEOF
5770	}
5771	return nil
5772}
5773func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
5774	l := len(dAtA)
5775	iNdEx := 0
5776	for iNdEx < l {
5777		preIndex := iNdEx
5778		var wire uint64
5779		for shift := uint(0); ; shift += 7 {
5780			if shift >= 64 {
5781				return ErrIntOverflowGenerated
5782			}
5783			if iNdEx >= l {
5784				return io.ErrUnexpectedEOF
5785			}
5786			b := dAtA[iNdEx]
5787			iNdEx++
5788			wire |= (uint64(b) & 0x7F) << shift
5789			if b < 0x80 {
5790				break
5791			}
5792		}
5793		fieldNum := int32(wire >> 3)
5794		wireType := int(wire & 0x7)
5795		if wireType == 4 {
5796			return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
5797		}
5798		if fieldNum <= 0 {
5799			return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5800		}
5801		switch fieldNum {
5802		case 1:
5803			if wireType != 2 {
5804				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5805			}
5806			var stringLen uint64
5807			for shift := uint(0); ; shift += 7 {
5808				if shift >= 64 {
5809					return ErrIntOverflowGenerated
5810				}
5811				if iNdEx >= l {
5812					return io.ErrUnexpectedEOF
5813				}
5814				b := dAtA[iNdEx]
5815				iNdEx++
5816				stringLen |= (uint64(b) & 0x7F) << shift
5817				if b < 0x80 {
5818					break
5819				}
5820			}
5821			intStringLen := int(stringLen)
5822			if intStringLen < 0 {
5823				return ErrInvalidLengthGenerated
5824			}
5825			postIndex := iNdEx + intStringLen
5826			if postIndex > l {
5827				return io.ErrUnexpectedEOF
5828			}
5829			m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
5830			iNdEx = postIndex
5831		case 2:
5832			if wireType != 2 {
5833				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5834			}
5835			var stringLen uint64
5836			for shift := uint(0); ; shift += 7 {
5837				if shift >= 64 {
5838					return ErrIntOverflowGenerated
5839				}
5840				if iNdEx >= l {
5841					return io.ErrUnexpectedEOF
5842				}
5843				b := dAtA[iNdEx]
5844				iNdEx++
5845				stringLen |= (uint64(b) & 0x7F) << shift
5846				if b < 0x80 {
5847					break
5848				}
5849			}
5850			intStringLen := int(stringLen)
5851			if intStringLen < 0 {
5852				return ErrInvalidLengthGenerated
5853			}
5854			postIndex := iNdEx + intStringLen
5855			if postIndex > l {
5856				return io.ErrUnexpectedEOF
5857			}
5858			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5859			iNdEx = postIndex
5860		case 4:
5861			if wireType != 2 {
5862				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5863			}
5864			var stringLen uint64
5865			for shift := uint(0); ; shift += 7 {
5866				if shift >= 64 {
5867					return ErrIntOverflowGenerated
5868				}
5869				if iNdEx >= l {
5870					return io.ErrUnexpectedEOF
5871				}
5872				b := dAtA[iNdEx]
5873				iNdEx++
5874				stringLen |= (uint64(b) & 0x7F) << shift
5875				if b < 0x80 {
5876					break
5877				}
5878			}
5879			intStringLen := int(stringLen)
5880			if intStringLen < 0 {
5881				return ErrInvalidLengthGenerated
5882			}
5883			postIndex := iNdEx + intStringLen
5884			if postIndex > l {
5885				return io.ErrUnexpectedEOF
5886			}
5887			m.Reason = string(dAtA[iNdEx:postIndex])
5888			iNdEx = postIndex
5889		case 5:
5890			if wireType != 2 {
5891				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5892			}
5893			var stringLen uint64
5894			for shift := uint(0); ; shift += 7 {
5895				if shift >= 64 {
5896					return ErrIntOverflowGenerated
5897				}
5898				if iNdEx >= l {
5899					return io.ErrUnexpectedEOF
5900				}
5901				b := dAtA[iNdEx]
5902				iNdEx++
5903				stringLen |= (uint64(b) & 0x7F) << shift
5904				if b < 0x80 {
5905					break
5906				}
5907			}
5908			intStringLen := int(stringLen)
5909			if intStringLen < 0 {
5910				return ErrInvalidLengthGenerated
5911			}
5912			postIndex := iNdEx + intStringLen
5913			if postIndex > l {
5914				return io.ErrUnexpectedEOF
5915			}
5916			m.Message = string(dAtA[iNdEx:postIndex])
5917			iNdEx = postIndex
5918		case 6:
5919			if wireType != 2 {
5920				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
5921			}
5922			var msglen int
5923			for shift := uint(0); ; shift += 7 {
5924				if shift >= 64 {
5925					return ErrIntOverflowGenerated
5926				}
5927				if iNdEx >= l {
5928					return io.ErrUnexpectedEOF
5929				}
5930				b := dAtA[iNdEx]
5931				iNdEx++
5932				msglen |= (int(b) & 0x7F) << shift
5933				if b < 0x80 {
5934					break
5935				}
5936			}
5937			if msglen < 0 {
5938				return ErrInvalidLengthGenerated
5939			}
5940			postIndex := iNdEx + msglen
5941			if postIndex > l {
5942				return io.ErrUnexpectedEOF
5943			}
5944			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5945				return err
5946			}
5947			iNdEx = postIndex
5948		case 7:
5949			if wireType != 2 {
5950				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5951			}
5952			var msglen int
5953			for shift := uint(0); ; shift += 7 {
5954				if shift >= 64 {
5955					return ErrIntOverflowGenerated
5956				}
5957				if iNdEx >= l {
5958					return io.ErrUnexpectedEOF
5959				}
5960				b := dAtA[iNdEx]
5961				iNdEx++
5962				msglen |= (int(b) & 0x7F) << shift
5963				if b < 0x80 {
5964					break
5965				}
5966			}
5967			if msglen < 0 {
5968				return ErrInvalidLengthGenerated
5969			}
5970			postIndex := iNdEx + msglen
5971			if postIndex > l {
5972				return io.ErrUnexpectedEOF
5973			}
5974			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5975				return err
5976			}
5977			iNdEx = postIndex
5978		default:
5979			iNdEx = preIndex
5980			skippy, err := skipGenerated(dAtA[iNdEx:])
5981			if err != nil {
5982				return err
5983			}
5984			if skippy < 0 {
5985				return ErrInvalidLengthGenerated
5986			}
5987			if (iNdEx + skippy) > l {
5988				return io.ErrUnexpectedEOF
5989			}
5990			iNdEx += skippy
5991		}
5992	}
5993
5994	if iNdEx > l {
5995		return io.ErrUnexpectedEOF
5996	}
5997	return nil
5998}
5999func (m *DeploymentList) Unmarshal(dAtA []byte) error {
6000	l := len(dAtA)
6001	iNdEx := 0
6002	for iNdEx < l {
6003		preIndex := iNdEx
6004		var wire uint64
6005		for shift := uint(0); ; shift += 7 {
6006			if shift >= 64 {
6007				return ErrIntOverflowGenerated
6008			}
6009			if iNdEx >= l {
6010				return io.ErrUnexpectedEOF
6011			}
6012			b := dAtA[iNdEx]
6013			iNdEx++
6014			wire |= (uint64(b) & 0x7F) << shift
6015			if b < 0x80 {
6016				break
6017			}
6018		}
6019		fieldNum := int32(wire >> 3)
6020		wireType := int(wire & 0x7)
6021		if wireType == 4 {
6022			return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
6023		}
6024		if fieldNum <= 0 {
6025			return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
6026		}
6027		switch fieldNum {
6028		case 1:
6029			if wireType != 2 {
6030				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
6031			}
6032			var msglen int
6033			for shift := uint(0); ; shift += 7 {
6034				if shift >= 64 {
6035					return ErrIntOverflowGenerated
6036				}
6037				if iNdEx >= l {
6038					return io.ErrUnexpectedEOF
6039				}
6040				b := dAtA[iNdEx]
6041				iNdEx++
6042				msglen |= (int(b) & 0x7F) << shift
6043				if b < 0x80 {
6044					break
6045				}
6046			}
6047			if msglen < 0 {
6048				return ErrInvalidLengthGenerated
6049			}
6050			postIndex := iNdEx + msglen
6051			if postIndex > l {
6052				return io.ErrUnexpectedEOF
6053			}
6054			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6055				return err
6056			}
6057			iNdEx = postIndex
6058		case 2:
6059			if wireType != 2 {
6060				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
6061			}
6062			var msglen int
6063			for shift := uint(0); ; shift += 7 {
6064				if shift >= 64 {
6065					return ErrIntOverflowGenerated
6066				}
6067				if iNdEx >= l {
6068					return io.ErrUnexpectedEOF
6069				}
6070				b := dAtA[iNdEx]
6071				iNdEx++
6072				msglen |= (int(b) & 0x7F) << shift
6073				if b < 0x80 {
6074					break
6075				}
6076			}
6077			if msglen < 0 {
6078				return ErrInvalidLengthGenerated
6079			}
6080			postIndex := iNdEx + msglen
6081			if postIndex > l {
6082				return io.ErrUnexpectedEOF
6083			}
6084			m.Items = append(m.Items, Deployment{})
6085			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6086				return err
6087			}
6088			iNdEx = postIndex
6089		default:
6090			iNdEx = preIndex
6091			skippy, err := skipGenerated(dAtA[iNdEx:])
6092			if err != nil {
6093				return err
6094			}
6095			if skippy < 0 {
6096				return ErrInvalidLengthGenerated
6097			}
6098			if (iNdEx + skippy) > l {
6099				return io.ErrUnexpectedEOF
6100			}
6101			iNdEx += skippy
6102		}
6103	}
6104
6105	if iNdEx > l {
6106		return io.ErrUnexpectedEOF
6107	}
6108	return nil
6109}
6110func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
6111	l := len(dAtA)
6112	iNdEx := 0
6113	for iNdEx < l {
6114		preIndex := iNdEx
6115		var wire uint64
6116		for shift := uint(0); ; shift += 7 {
6117			if shift >= 64 {
6118				return ErrIntOverflowGenerated
6119			}
6120			if iNdEx >= l {
6121				return io.ErrUnexpectedEOF
6122			}
6123			b := dAtA[iNdEx]
6124			iNdEx++
6125			wire |= (uint64(b) & 0x7F) << shift
6126			if b < 0x80 {
6127				break
6128			}
6129		}
6130		fieldNum := int32(wire >> 3)
6131		wireType := int(wire & 0x7)
6132		if wireType == 4 {
6133			return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
6134		}
6135		if fieldNum <= 0 {
6136			return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
6137		}
6138		switch fieldNum {
6139		case 1:
6140			if wireType != 2 {
6141				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6142			}
6143			var stringLen uint64
6144			for shift := uint(0); ; shift += 7 {
6145				if shift >= 64 {
6146					return ErrIntOverflowGenerated
6147				}
6148				if iNdEx >= l {
6149					return io.ErrUnexpectedEOF
6150				}
6151				b := dAtA[iNdEx]
6152				iNdEx++
6153				stringLen |= (uint64(b) & 0x7F) << shift
6154				if b < 0x80 {
6155					break
6156				}
6157			}
6158			intStringLen := int(stringLen)
6159			if intStringLen < 0 {
6160				return ErrInvalidLengthGenerated
6161			}
6162			postIndex := iNdEx + intStringLen
6163			if postIndex > l {
6164				return io.ErrUnexpectedEOF
6165			}
6166			m.Name = string(dAtA[iNdEx:postIndex])
6167			iNdEx = postIndex
6168		case 2:
6169			if wireType != 2 {
6170				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
6171			}
6172			var msglen int
6173			for shift := uint(0); ; shift += 7 {
6174				if shift >= 64 {
6175					return ErrIntOverflowGenerated
6176				}
6177				if iNdEx >= l {
6178					return io.ErrUnexpectedEOF
6179				}
6180				b := dAtA[iNdEx]
6181				iNdEx++
6182				msglen |= (int(b) & 0x7F) << shift
6183				if b < 0x80 {
6184					break
6185				}
6186			}
6187			if msglen < 0 {
6188				return ErrInvalidLengthGenerated
6189			}
6190			postIndex := iNdEx + msglen
6191			if postIndex > l {
6192				return io.ErrUnexpectedEOF
6193			}
6194			if m.UpdatedAnnotations == nil {
6195				m.UpdatedAnnotations = make(map[string]string)
6196			}
6197			var mapkey string
6198			var mapvalue string
6199			for iNdEx < postIndex {
6200				entryPreIndex := iNdEx
6201				var wire uint64
6202				for shift := uint(0); ; shift += 7 {
6203					if shift >= 64 {
6204						return ErrIntOverflowGenerated
6205					}
6206					if iNdEx >= l {
6207						return io.ErrUnexpectedEOF
6208					}
6209					b := dAtA[iNdEx]
6210					iNdEx++
6211					wire |= (uint64(b) & 0x7F) << shift
6212					if b < 0x80 {
6213						break
6214					}
6215				}
6216				fieldNum := int32(wire >> 3)
6217				if fieldNum == 1 {
6218					var stringLenmapkey uint64
6219					for shift := uint(0); ; shift += 7 {
6220						if shift >= 64 {
6221							return ErrIntOverflowGenerated
6222						}
6223						if iNdEx >= l {
6224							return io.ErrUnexpectedEOF
6225						}
6226						b := dAtA[iNdEx]
6227						iNdEx++
6228						stringLenmapkey |= (uint64(b) & 0x7F) << shift
6229						if b < 0x80 {
6230							break
6231						}
6232					}
6233					intStringLenmapkey := int(stringLenmapkey)
6234					if intStringLenmapkey < 0 {
6235						return ErrInvalidLengthGenerated
6236					}
6237					postStringIndexmapkey := iNdEx + intStringLenmapkey
6238					if postStringIndexmapkey > l {
6239						return io.ErrUnexpectedEOF
6240					}
6241					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6242					iNdEx = postStringIndexmapkey
6243				} else if fieldNum == 2 {
6244					var stringLenmapvalue uint64
6245					for shift := uint(0); ; shift += 7 {
6246						if shift >= 64 {
6247							return ErrIntOverflowGenerated
6248						}
6249						if iNdEx >= l {
6250							return io.ErrUnexpectedEOF
6251						}
6252						b := dAtA[iNdEx]
6253						iNdEx++
6254						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6255						if b < 0x80 {
6256							break
6257						}
6258					}
6259					intStringLenmapvalue := int(stringLenmapvalue)
6260					if intStringLenmapvalue < 0 {
6261						return ErrInvalidLengthGenerated
6262					}
6263					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6264					if postStringIndexmapvalue > l {
6265						return io.ErrUnexpectedEOF
6266					}
6267					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6268					iNdEx = postStringIndexmapvalue
6269				} else {
6270					iNdEx = entryPreIndex
6271					skippy, err := skipGenerated(dAtA[iNdEx:])
6272					if err != nil {
6273						return err
6274					}
6275					if skippy < 0 {
6276						return ErrInvalidLengthGenerated
6277					}
6278					if (iNdEx + skippy) > postIndex {
6279						return io.ErrUnexpectedEOF
6280					}
6281					iNdEx += skippy
6282				}
6283			}
6284			m.UpdatedAnnotations[mapkey] = mapvalue
6285			iNdEx = postIndex
6286		case 3:
6287			if wireType != 2 {
6288				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6289			}
6290			var msglen int
6291			for shift := uint(0); ; shift += 7 {
6292				if shift >= 64 {
6293					return ErrIntOverflowGenerated
6294				}
6295				if iNdEx >= l {
6296					return io.ErrUnexpectedEOF
6297				}
6298				b := dAtA[iNdEx]
6299				iNdEx++
6300				msglen |= (int(b) & 0x7F) << shift
6301				if b < 0x80 {
6302					break
6303				}
6304			}
6305			if msglen < 0 {
6306				return ErrInvalidLengthGenerated
6307			}
6308			postIndex := iNdEx + msglen
6309			if postIndex > l {
6310				return io.ErrUnexpectedEOF
6311			}
6312			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6313				return err
6314			}
6315			iNdEx = postIndex
6316		default:
6317			iNdEx = preIndex
6318			skippy, err := skipGenerated(dAtA[iNdEx:])
6319			if err != nil {
6320				return err
6321			}
6322			if skippy < 0 {
6323				return ErrInvalidLengthGenerated
6324			}
6325			if (iNdEx + skippy) > l {
6326				return io.ErrUnexpectedEOF
6327			}
6328			iNdEx += skippy
6329		}
6330	}
6331
6332	if iNdEx > l {
6333		return io.ErrUnexpectedEOF
6334	}
6335	return nil
6336}
6337func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
6338	l := len(dAtA)
6339	iNdEx := 0
6340	for iNdEx < l {
6341		preIndex := iNdEx
6342		var wire uint64
6343		for shift := uint(0); ; shift += 7 {
6344			if shift >= 64 {
6345				return ErrIntOverflowGenerated
6346			}
6347			if iNdEx >= l {
6348				return io.ErrUnexpectedEOF
6349			}
6350			b := dAtA[iNdEx]
6351			iNdEx++
6352			wire |= (uint64(b) & 0x7F) << shift
6353			if b < 0x80 {
6354				break
6355			}
6356		}
6357		fieldNum := int32(wire >> 3)
6358		wireType := int(wire & 0x7)
6359		if wireType == 4 {
6360			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
6361		}
6362		if fieldNum <= 0 {
6363			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
6364		}
6365		switch fieldNum {
6366		case 1:
6367			if wireType != 0 {
6368				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6369			}
6370			var v int32
6371			for shift := uint(0); ; shift += 7 {
6372				if shift >= 64 {
6373					return ErrIntOverflowGenerated
6374				}
6375				if iNdEx >= l {
6376					return io.ErrUnexpectedEOF
6377				}
6378				b := dAtA[iNdEx]
6379				iNdEx++
6380				v |= (int32(b) & 0x7F) << shift
6381				if b < 0x80 {
6382					break
6383				}
6384			}
6385			m.Replicas = &v
6386		case 2:
6387			if wireType != 2 {
6388				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
6389			}
6390			var msglen int
6391			for shift := uint(0); ; shift += 7 {
6392				if shift >= 64 {
6393					return ErrIntOverflowGenerated
6394				}
6395				if iNdEx >= l {
6396					return io.ErrUnexpectedEOF
6397				}
6398				b := dAtA[iNdEx]
6399				iNdEx++
6400				msglen |= (int(b) & 0x7F) << shift
6401				if b < 0x80 {
6402					break
6403				}
6404			}
6405			if msglen < 0 {
6406				return ErrInvalidLengthGenerated
6407			}
6408			postIndex := iNdEx + msglen
6409			if postIndex > l {
6410				return io.ErrUnexpectedEOF
6411			}
6412			if m.Selector == nil {
6413				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
6414			}
6415			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6416				return err
6417			}
6418			iNdEx = postIndex
6419		case 3:
6420			if wireType != 2 {
6421				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
6422			}
6423			var msglen int
6424			for shift := uint(0); ; shift += 7 {
6425				if shift >= 64 {
6426					return ErrIntOverflowGenerated
6427				}
6428				if iNdEx >= l {
6429					return io.ErrUnexpectedEOF
6430				}
6431				b := dAtA[iNdEx]
6432				iNdEx++
6433				msglen |= (int(b) & 0x7F) << shift
6434				if b < 0x80 {
6435					break
6436				}
6437			}
6438			if msglen < 0 {
6439				return ErrInvalidLengthGenerated
6440			}
6441			postIndex := iNdEx + msglen
6442			if postIndex > l {
6443				return io.ErrUnexpectedEOF
6444			}
6445			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6446				return err
6447			}
6448			iNdEx = postIndex
6449		case 4:
6450			if wireType != 2 {
6451				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
6452			}
6453			var msglen int
6454			for shift := uint(0); ; shift += 7 {
6455				if shift >= 64 {
6456					return ErrIntOverflowGenerated
6457				}
6458				if iNdEx >= l {
6459					return io.ErrUnexpectedEOF
6460				}
6461				b := dAtA[iNdEx]
6462				iNdEx++
6463				msglen |= (int(b) & 0x7F) << shift
6464				if b < 0x80 {
6465					break
6466				}
6467			}
6468			if msglen < 0 {
6469				return ErrInvalidLengthGenerated
6470			}
6471			postIndex := iNdEx + msglen
6472			if postIndex > l {
6473				return io.ErrUnexpectedEOF
6474			}
6475			if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6476				return err
6477			}
6478			iNdEx = postIndex
6479		case 5:
6480			if wireType != 0 {
6481				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
6482			}
6483			m.MinReadySeconds = 0
6484			for shift := uint(0); ; shift += 7 {
6485				if shift >= 64 {
6486					return ErrIntOverflowGenerated
6487				}
6488				if iNdEx >= l {
6489					return io.ErrUnexpectedEOF
6490				}
6491				b := dAtA[iNdEx]
6492				iNdEx++
6493				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
6494				if b < 0x80 {
6495					break
6496				}
6497			}
6498		case 6:
6499			if wireType != 0 {
6500				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
6501			}
6502			var v int32
6503			for shift := uint(0); ; shift += 7 {
6504				if shift >= 64 {
6505					return ErrIntOverflowGenerated
6506				}
6507				if iNdEx >= l {
6508					return io.ErrUnexpectedEOF
6509				}
6510				b := dAtA[iNdEx]
6511				iNdEx++
6512				v |= (int32(b) & 0x7F) << shift
6513				if b < 0x80 {
6514					break
6515				}
6516			}
6517			m.RevisionHistoryLimit = &v
6518		case 7:
6519			if wireType != 0 {
6520				return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
6521			}
6522			var v int
6523			for shift := uint(0); ; shift += 7 {
6524				if shift >= 64 {
6525					return ErrIntOverflowGenerated
6526				}
6527				if iNdEx >= l {
6528					return io.ErrUnexpectedEOF
6529				}
6530				b := dAtA[iNdEx]
6531				iNdEx++
6532				v |= (int(b) & 0x7F) << shift
6533				if b < 0x80 {
6534					break
6535				}
6536			}
6537			m.Paused = bool(v != 0)
6538		case 8:
6539			if wireType != 2 {
6540				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
6541			}
6542			var msglen int
6543			for shift := uint(0); ; shift += 7 {
6544				if shift >= 64 {
6545					return ErrIntOverflowGenerated
6546				}
6547				if iNdEx >= l {
6548					return io.ErrUnexpectedEOF
6549				}
6550				b := dAtA[iNdEx]
6551				iNdEx++
6552				msglen |= (int(b) & 0x7F) << shift
6553				if b < 0x80 {
6554					break
6555				}
6556			}
6557			if msglen < 0 {
6558				return ErrInvalidLengthGenerated
6559			}
6560			postIndex := iNdEx + msglen
6561			if postIndex > l {
6562				return io.ErrUnexpectedEOF
6563			}
6564			if m.RollbackTo == nil {
6565				m.RollbackTo = &RollbackConfig{}
6566			}
6567			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6568				return err
6569			}
6570			iNdEx = postIndex
6571		case 9:
6572			if wireType != 0 {
6573				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
6574			}
6575			var v int32
6576			for shift := uint(0); ; shift += 7 {
6577				if shift >= 64 {
6578					return ErrIntOverflowGenerated
6579				}
6580				if iNdEx >= l {
6581					return io.ErrUnexpectedEOF
6582				}
6583				b := dAtA[iNdEx]
6584				iNdEx++
6585				v |= (int32(b) & 0x7F) << shift
6586				if b < 0x80 {
6587					break
6588				}
6589			}
6590			m.ProgressDeadlineSeconds = &v
6591		default:
6592			iNdEx = preIndex
6593			skippy, err := skipGenerated(dAtA[iNdEx:])
6594			if err != nil {
6595				return err
6596			}
6597			if skippy < 0 {
6598				return ErrInvalidLengthGenerated
6599			}
6600			if (iNdEx + skippy) > l {
6601				return io.ErrUnexpectedEOF
6602			}
6603			iNdEx += skippy
6604		}
6605	}
6606
6607	if iNdEx > l {
6608		return io.ErrUnexpectedEOF
6609	}
6610	return nil
6611}
6612func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
6613	l := len(dAtA)
6614	iNdEx := 0
6615	for iNdEx < l {
6616		preIndex := iNdEx
6617		var wire uint64
6618		for shift := uint(0); ; shift += 7 {
6619			if shift >= 64 {
6620				return ErrIntOverflowGenerated
6621			}
6622			if iNdEx >= l {
6623				return io.ErrUnexpectedEOF
6624			}
6625			b := dAtA[iNdEx]
6626			iNdEx++
6627			wire |= (uint64(b) & 0x7F) << shift
6628			if b < 0x80 {
6629				break
6630			}
6631		}
6632		fieldNum := int32(wire >> 3)
6633		wireType := int(wire & 0x7)
6634		if wireType == 4 {
6635			return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
6636		}
6637		if fieldNum <= 0 {
6638			return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6639		}
6640		switch fieldNum {
6641		case 1:
6642			if wireType != 0 {
6643				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6644			}
6645			m.ObservedGeneration = 0
6646			for shift := uint(0); ; shift += 7 {
6647				if shift >= 64 {
6648					return ErrIntOverflowGenerated
6649				}
6650				if iNdEx >= l {
6651					return io.ErrUnexpectedEOF
6652				}
6653				b := dAtA[iNdEx]
6654				iNdEx++
6655				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
6656				if b < 0x80 {
6657					break
6658				}
6659			}
6660		case 2:
6661			if wireType != 0 {
6662				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6663			}
6664			m.Replicas = 0
6665			for shift := uint(0); ; shift += 7 {
6666				if shift >= 64 {
6667					return ErrIntOverflowGenerated
6668				}
6669				if iNdEx >= l {
6670					return io.ErrUnexpectedEOF
6671				}
6672				b := dAtA[iNdEx]
6673				iNdEx++
6674				m.Replicas |= (int32(b) & 0x7F) << shift
6675				if b < 0x80 {
6676					break
6677				}
6678			}
6679		case 3:
6680			if wireType != 0 {
6681				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
6682			}
6683			m.UpdatedReplicas = 0
6684			for shift := uint(0); ; shift += 7 {
6685				if shift >= 64 {
6686					return ErrIntOverflowGenerated
6687				}
6688				if iNdEx >= l {
6689					return io.ErrUnexpectedEOF
6690				}
6691				b := dAtA[iNdEx]
6692				iNdEx++
6693				m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
6694				if b < 0x80 {
6695					break
6696				}
6697			}
6698		case 4:
6699			if wireType != 0 {
6700				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
6701			}
6702			m.AvailableReplicas = 0
6703			for shift := uint(0); ; shift += 7 {
6704				if shift >= 64 {
6705					return ErrIntOverflowGenerated
6706				}
6707				if iNdEx >= l {
6708					return io.ErrUnexpectedEOF
6709				}
6710				b := dAtA[iNdEx]
6711				iNdEx++
6712				m.AvailableReplicas |= (int32(b) & 0x7F) << shift
6713				if b < 0x80 {
6714					break
6715				}
6716			}
6717		case 5:
6718			if wireType != 0 {
6719				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
6720			}
6721			m.UnavailableReplicas = 0
6722			for shift := uint(0); ; shift += 7 {
6723				if shift >= 64 {
6724					return ErrIntOverflowGenerated
6725				}
6726				if iNdEx >= l {
6727					return io.ErrUnexpectedEOF
6728				}
6729				b := dAtA[iNdEx]
6730				iNdEx++
6731				m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
6732				if b < 0x80 {
6733					break
6734				}
6735			}
6736		case 6:
6737			if wireType != 2 {
6738				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
6739			}
6740			var msglen int
6741			for shift := uint(0); ; shift += 7 {
6742				if shift >= 64 {
6743					return ErrIntOverflowGenerated
6744				}
6745				if iNdEx >= l {
6746					return io.ErrUnexpectedEOF
6747				}
6748				b := dAtA[iNdEx]
6749				iNdEx++
6750				msglen |= (int(b) & 0x7F) << shift
6751				if b < 0x80 {
6752					break
6753				}
6754			}
6755			if msglen < 0 {
6756				return ErrInvalidLengthGenerated
6757			}
6758			postIndex := iNdEx + msglen
6759			if postIndex > l {
6760				return io.ErrUnexpectedEOF
6761			}
6762			m.Conditions = append(m.Conditions, DeploymentCondition{})
6763			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6764				return err
6765			}
6766			iNdEx = postIndex
6767		case 7:
6768			if wireType != 0 {
6769				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6770			}
6771			m.ReadyReplicas = 0
6772			for shift := uint(0); ; shift += 7 {
6773				if shift >= 64 {
6774					return ErrIntOverflowGenerated
6775				}
6776				if iNdEx >= l {
6777					return io.ErrUnexpectedEOF
6778				}
6779				b := dAtA[iNdEx]
6780				iNdEx++
6781				m.ReadyReplicas |= (int32(b) & 0x7F) << shift
6782				if b < 0x80 {
6783					break
6784				}
6785			}
6786		case 8:
6787			if wireType != 0 {
6788				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
6789			}
6790			var v int32
6791			for shift := uint(0); ; shift += 7 {
6792				if shift >= 64 {
6793					return ErrIntOverflowGenerated
6794				}
6795				if iNdEx >= l {
6796					return io.ErrUnexpectedEOF
6797				}
6798				b := dAtA[iNdEx]
6799				iNdEx++
6800				v |= (int32(b) & 0x7F) << shift
6801				if b < 0x80 {
6802					break
6803				}
6804			}
6805			m.CollisionCount = &v
6806		default:
6807			iNdEx = preIndex
6808			skippy, err := skipGenerated(dAtA[iNdEx:])
6809			if err != nil {
6810				return err
6811			}
6812			if skippy < 0 {
6813				return ErrInvalidLengthGenerated
6814			}
6815			if (iNdEx + skippy) > l {
6816				return io.ErrUnexpectedEOF
6817			}
6818			iNdEx += skippy
6819		}
6820	}
6821
6822	if iNdEx > l {
6823		return io.ErrUnexpectedEOF
6824	}
6825	return nil
6826}
6827func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
6828	l := len(dAtA)
6829	iNdEx := 0
6830	for iNdEx < l {
6831		preIndex := iNdEx
6832		var wire uint64
6833		for shift := uint(0); ; shift += 7 {
6834			if shift >= 64 {
6835				return ErrIntOverflowGenerated
6836			}
6837			if iNdEx >= l {
6838				return io.ErrUnexpectedEOF
6839			}
6840			b := dAtA[iNdEx]
6841			iNdEx++
6842			wire |= (uint64(b) & 0x7F) << shift
6843			if b < 0x80 {
6844				break
6845			}
6846		}
6847		fieldNum := int32(wire >> 3)
6848		wireType := int(wire & 0x7)
6849		if wireType == 4 {
6850			return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
6851		}
6852		if fieldNum <= 0 {
6853			return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
6854		}
6855		switch fieldNum {
6856		case 1:
6857			if wireType != 2 {
6858				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6859			}
6860			var stringLen uint64
6861			for shift := uint(0); ; shift += 7 {
6862				if shift >= 64 {
6863					return ErrIntOverflowGenerated
6864				}
6865				if iNdEx >= l {
6866					return io.ErrUnexpectedEOF
6867				}
6868				b := dAtA[iNdEx]
6869				iNdEx++
6870				stringLen |= (uint64(b) & 0x7F) << shift
6871				if b < 0x80 {
6872					break
6873				}
6874			}
6875			intStringLen := int(stringLen)
6876			if intStringLen < 0 {
6877				return ErrInvalidLengthGenerated
6878			}
6879			postIndex := iNdEx + intStringLen
6880			if postIndex > l {
6881				return io.ErrUnexpectedEOF
6882			}
6883			m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
6884			iNdEx = postIndex
6885		case 2:
6886			if wireType != 2 {
6887				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6888			}
6889			var msglen int
6890			for shift := uint(0); ; shift += 7 {
6891				if shift >= 64 {
6892					return ErrIntOverflowGenerated
6893				}
6894				if iNdEx >= l {
6895					return io.ErrUnexpectedEOF
6896				}
6897				b := dAtA[iNdEx]
6898				iNdEx++
6899				msglen |= (int(b) & 0x7F) << shift
6900				if b < 0x80 {
6901					break
6902				}
6903			}
6904			if msglen < 0 {
6905				return ErrInvalidLengthGenerated
6906			}
6907			postIndex := iNdEx + msglen
6908			if postIndex > l {
6909				return io.ErrUnexpectedEOF
6910			}
6911			if m.RollingUpdate == nil {
6912				m.RollingUpdate = &RollingUpdateDeployment{}
6913			}
6914			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6915				return err
6916			}
6917			iNdEx = postIndex
6918		default:
6919			iNdEx = preIndex
6920			skippy, err := skipGenerated(dAtA[iNdEx:])
6921			if err != nil {
6922				return err
6923			}
6924			if skippy < 0 {
6925				return ErrInvalidLengthGenerated
6926			}
6927			if (iNdEx + skippy) > l {
6928				return io.ErrUnexpectedEOF
6929			}
6930			iNdEx += skippy
6931		}
6932	}
6933
6934	if iNdEx > l {
6935		return io.ErrUnexpectedEOF
6936	}
6937	return nil
6938}
6939func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error {
6940	l := len(dAtA)
6941	iNdEx := 0
6942	for iNdEx < l {
6943		preIndex := iNdEx
6944		var wire uint64
6945		for shift := uint(0); ; shift += 7 {
6946			if shift >= 64 {
6947				return ErrIntOverflowGenerated
6948			}
6949			if iNdEx >= l {
6950				return io.ErrUnexpectedEOF
6951			}
6952			b := dAtA[iNdEx]
6953			iNdEx++
6954			wire |= (uint64(b) & 0x7F) << shift
6955			if b < 0x80 {
6956				break
6957			}
6958		}
6959		fieldNum := int32(wire >> 3)
6960		wireType := int(wire & 0x7)
6961		if wireType == 4 {
6962			return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group")
6963		}
6964		if fieldNum <= 0 {
6965			return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
6966		}
6967		switch fieldNum {
6968		case 1:
6969			if wireType != 2 {
6970				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
6971			}
6972			var stringLen uint64
6973			for shift := uint(0); ; shift += 7 {
6974				if shift >= 64 {
6975					return ErrIntOverflowGenerated
6976				}
6977				if iNdEx >= l {
6978					return io.ErrUnexpectedEOF
6979				}
6980				b := dAtA[iNdEx]
6981				iNdEx++
6982				stringLen |= (uint64(b) & 0x7F) << shift
6983				if b < 0x80 {
6984					break
6985				}
6986			}
6987			intStringLen := int(stringLen)
6988			if intStringLen < 0 {
6989				return ErrInvalidLengthGenerated
6990			}
6991			postIndex := iNdEx + intStringLen
6992			if postIndex > l {
6993				return io.ErrUnexpectedEOF
6994			}
6995			m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex])
6996			iNdEx = postIndex
6997		case 2:
6998			if wireType != 2 {
6999				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
7000			}
7001			var msglen int
7002			for shift := uint(0); ; shift += 7 {
7003				if shift >= 64 {
7004					return ErrIntOverflowGenerated
7005				}
7006				if iNdEx >= l {
7007					return io.ErrUnexpectedEOF
7008				}
7009				b := dAtA[iNdEx]
7010				iNdEx++
7011				msglen |= (int(b) & 0x7F) << shift
7012				if b < 0x80 {
7013					break
7014				}
7015			}
7016			if msglen < 0 {
7017				return ErrInvalidLengthGenerated
7018			}
7019			postIndex := iNdEx + msglen
7020			if postIndex > l {
7021				return io.ErrUnexpectedEOF
7022			}
7023			m.Ranges = append(m.Ranges, IDRange{})
7024			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7025				return err
7026			}
7027			iNdEx = postIndex
7028		default:
7029			iNdEx = preIndex
7030			skippy, err := skipGenerated(dAtA[iNdEx:])
7031			if err != nil {
7032				return err
7033			}
7034			if skippy < 0 {
7035				return ErrInvalidLengthGenerated
7036			}
7037			if (iNdEx + skippy) > l {
7038				return io.ErrUnexpectedEOF
7039			}
7040			iNdEx += skippy
7041		}
7042	}
7043
7044	if iNdEx > l {
7045		return io.ErrUnexpectedEOF
7046	}
7047	return nil
7048}
7049func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error {
7050	l := len(dAtA)
7051	iNdEx := 0
7052	for iNdEx < l {
7053		preIndex := iNdEx
7054		var wire uint64
7055		for shift := uint(0); ; shift += 7 {
7056			if shift >= 64 {
7057				return ErrIntOverflowGenerated
7058			}
7059			if iNdEx >= l {
7060				return io.ErrUnexpectedEOF
7061			}
7062			b := dAtA[iNdEx]
7063			iNdEx++
7064			wire |= (uint64(b) & 0x7F) << shift
7065			if b < 0x80 {
7066				break
7067			}
7068		}
7069		fieldNum := int32(wire >> 3)
7070		wireType := int(wire & 0x7)
7071		if wireType == 4 {
7072			return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
7073		}
7074		if fieldNum <= 0 {
7075			return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
7076		}
7077		switch fieldNum {
7078		case 1:
7079			if wireType != 2 {
7080				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
7081			}
7082			var stringLen uint64
7083			for shift := uint(0); ; shift += 7 {
7084				if shift >= 64 {
7085					return ErrIntOverflowGenerated
7086				}
7087				if iNdEx >= l {
7088					return io.ErrUnexpectedEOF
7089				}
7090				b := dAtA[iNdEx]
7091				iNdEx++
7092				stringLen |= (uint64(b) & 0x7F) << shift
7093				if b < 0x80 {
7094					break
7095				}
7096			}
7097			intStringLen := int(stringLen)
7098			if intStringLen < 0 {
7099				return ErrInvalidLengthGenerated
7100			}
7101			postIndex := iNdEx + intStringLen
7102			if postIndex > l {
7103				return io.ErrUnexpectedEOF
7104			}
7105			m.Path = string(dAtA[iNdEx:postIndex])
7106			iNdEx = postIndex
7107		case 2:
7108			if wireType != 2 {
7109				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
7110			}
7111			var msglen int
7112			for shift := uint(0); ; shift += 7 {
7113				if shift >= 64 {
7114					return ErrIntOverflowGenerated
7115				}
7116				if iNdEx >= l {
7117					return io.ErrUnexpectedEOF
7118				}
7119				b := dAtA[iNdEx]
7120				iNdEx++
7121				msglen |= (int(b) & 0x7F) << shift
7122				if b < 0x80 {
7123					break
7124				}
7125			}
7126			if msglen < 0 {
7127				return ErrInvalidLengthGenerated
7128			}
7129			postIndex := iNdEx + msglen
7130			if postIndex > l {
7131				return io.ErrUnexpectedEOF
7132			}
7133			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7134				return err
7135			}
7136			iNdEx = postIndex
7137		default:
7138			iNdEx = preIndex
7139			skippy, err := skipGenerated(dAtA[iNdEx:])
7140			if err != nil {
7141				return err
7142			}
7143			if skippy < 0 {
7144				return ErrInvalidLengthGenerated
7145			}
7146			if (iNdEx + skippy) > l {
7147				return io.ErrUnexpectedEOF
7148			}
7149			iNdEx += skippy
7150		}
7151	}
7152
7153	if iNdEx > l {
7154		return io.ErrUnexpectedEOF
7155	}
7156	return nil
7157}
7158func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error {
7159	l := len(dAtA)
7160	iNdEx := 0
7161	for iNdEx < l {
7162		preIndex := iNdEx
7163		var wire uint64
7164		for shift := uint(0); ; shift += 7 {
7165			if shift >= 64 {
7166				return ErrIntOverflowGenerated
7167			}
7168			if iNdEx >= l {
7169				return io.ErrUnexpectedEOF
7170			}
7171			b := dAtA[iNdEx]
7172			iNdEx++
7173			wire |= (uint64(b) & 0x7F) << shift
7174			if b < 0x80 {
7175				break
7176			}
7177		}
7178		fieldNum := int32(wire >> 3)
7179		wireType := int(wire & 0x7)
7180		if wireType == 4 {
7181			return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
7182		}
7183		if fieldNum <= 0 {
7184			return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
7185		}
7186		switch fieldNum {
7187		case 1:
7188			if wireType != 2 {
7189				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
7190			}
7191			var msglen int
7192			for shift := uint(0); ; shift += 7 {
7193				if shift >= 64 {
7194					return ErrIntOverflowGenerated
7195				}
7196				if iNdEx >= l {
7197					return io.ErrUnexpectedEOF
7198				}
7199				b := dAtA[iNdEx]
7200				iNdEx++
7201				msglen |= (int(b) & 0x7F) << shift
7202				if b < 0x80 {
7203					break
7204				}
7205			}
7206			if msglen < 0 {
7207				return ErrInvalidLengthGenerated
7208			}
7209			postIndex := iNdEx + msglen
7210			if postIndex > l {
7211				return io.ErrUnexpectedEOF
7212			}
7213			m.Paths = append(m.Paths, HTTPIngressPath{})
7214			if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7215				return err
7216			}
7217			iNdEx = postIndex
7218		default:
7219			iNdEx = preIndex
7220			skippy, err := skipGenerated(dAtA[iNdEx:])
7221			if err != nil {
7222				return err
7223			}
7224			if skippy < 0 {
7225				return ErrInvalidLengthGenerated
7226			}
7227			if (iNdEx + skippy) > l {
7228				return io.ErrUnexpectedEOF
7229			}
7230			iNdEx += skippy
7231		}
7232	}
7233
7234	if iNdEx > l {
7235		return io.ErrUnexpectedEOF
7236	}
7237	return nil
7238}
7239func (m *HostPortRange) Unmarshal(dAtA []byte) error {
7240	l := len(dAtA)
7241	iNdEx := 0
7242	for iNdEx < l {
7243		preIndex := iNdEx
7244		var wire uint64
7245		for shift := uint(0); ; shift += 7 {
7246			if shift >= 64 {
7247				return ErrIntOverflowGenerated
7248			}
7249			if iNdEx >= l {
7250				return io.ErrUnexpectedEOF
7251			}
7252			b := dAtA[iNdEx]
7253			iNdEx++
7254			wire |= (uint64(b) & 0x7F) << shift
7255			if b < 0x80 {
7256				break
7257			}
7258		}
7259		fieldNum := int32(wire >> 3)
7260		wireType := int(wire & 0x7)
7261		if wireType == 4 {
7262			return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group")
7263		}
7264		if fieldNum <= 0 {
7265			return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire)
7266		}
7267		switch fieldNum {
7268		case 1:
7269			if wireType != 0 {
7270				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7271			}
7272			m.Min = 0
7273			for shift := uint(0); ; shift += 7 {
7274				if shift >= 64 {
7275					return ErrIntOverflowGenerated
7276				}
7277				if iNdEx >= l {
7278					return io.ErrUnexpectedEOF
7279				}
7280				b := dAtA[iNdEx]
7281				iNdEx++
7282				m.Min |= (int32(b) & 0x7F) << shift
7283				if b < 0x80 {
7284					break
7285				}
7286			}
7287		case 2:
7288			if wireType != 0 {
7289				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7290			}
7291			m.Max = 0
7292			for shift := uint(0); ; shift += 7 {
7293				if shift >= 64 {
7294					return ErrIntOverflowGenerated
7295				}
7296				if iNdEx >= l {
7297					return io.ErrUnexpectedEOF
7298				}
7299				b := dAtA[iNdEx]
7300				iNdEx++
7301				m.Max |= (int32(b) & 0x7F) << shift
7302				if b < 0x80 {
7303					break
7304				}
7305			}
7306		default:
7307			iNdEx = preIndex
7308			skippy, err := skipGenerated(dAtA[iNdEx:])
7309			if err != nil {
7310				return err
7311			}
7312			if skippy < 0 {
7313				return ErrInvalidLengthGenerated
7314			}
7315			if (iNdEx + skippy) > l {
7316				return io.ErrUnexpectedEOF
7317			}
7318			iNdEx += skippy
7319		}
7320	}
7321
7322	if iNdEx > l {
7323		return io.ErrUnexpectedEOF
7324	}
7325	return nil
7326}
7327func (m *IDRange) Unmarshal(dAtA []byte) error {
7328	l := len(dAtA)
7329	iNdEx := 0
7330	for iNdEx < l {
7331		preIndex := iNdEx
7332		var wire uint64
7333		for shift := uint(0); ; shift += 7 {
7334			if shift >= 64 {
7335				return ErrIntOverflowGenerated
7336			}
7337			if iNdEx >= l {
7338				return io.ErrUnexpectedEOF
7339			}
7340			b := dAtA[iNdEx]
7341			iNdEx++
7342			wire |= (uint64(b) & 0x7F) << shift
7343			if b < 0x80 {
7344				break
7345			}
7346		}
7347		fieldNum := int32(wire >> 3)
7348		wireType := int(wire & 0x7)
7349		if wireType == 4 {
7350			return fmt.Errorf("proto: IDRange: wiretype end group for non-group")
7351		}
7352		if fieldNum <= 0 {
7353			return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire)
7354		}
7355		switch fieldNum {
7356		case 1:
7357			if wireType != 0 {
7358				return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType)
7359			}
7360			m.Min = 0
7361			for shift := uint(0); ; shift += 7 {
7362				if shift >= 64 {
7363					return ErrIntOverflowGenerated
7364				}
7365				if iNdEx >= l {
7366					return io.ErrUnexpectedEOF
7367				}
7368				b := dAtA[iNdEx]
7369				iNdEx++
7370				m.Min |= (int64(b) & 0x7F) << shift
7371				if b < 0x80 {
7372					break
7373				}
7374			}
7375		case 2:
7376			if wireType != 0 {
7377				return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType)
7378			}
7379			m.Max = 0
7380			for shift := uint(0); ; shift += 7 {
7381				if shift >= 64 {
7382					return ErrIntOverflowGenerated
7383				}
7384				if iNdEx >= l {
7385					return io.ErrUnexpectedEOF
7386				}
7387				b := dAtA[iNdEx]
7388				iNdEx++
7389				m.Max |= (int64(b) & 0x7F) << shift
7390				if b < 0x80 {
7391					break
7392				}
7393			}
7394		default:
7395			iNdEx = preIndex
7396			skippy, err := skipGenerated(dAtA[iNdEx:])
7397			if err != nil {
7398				return err
7399			}
7400			if skippy < 0 {
7401				return ErrInvalidLengthGenerated
7402			}
7403			if (iNdEx + skippy) > l {
7404				return io.ErrUnexpectedEOF
7405			}
7406			iNdEx += skippy
7407		}
7408	}
7409
7410	if iNdEx > l {
7411		return io.ErrUnexpectedEOF
7412	}
7413	return nil
7414}
7415func (m *IPBlock) Unmarshal(dAtA []byte) error {
7416	l := len(dAtA)
7417	iNdEx := 0
7418	for iNdEx < l {
7419		preIndex := iNdEx
7420		var wire uint64
7421		for shift := uint(0); ; shift += 7 {
7422			if shift >= 64 {
7423				return ErrIntOverflowGenerated
7424			}
7425			if iNdEx >= l {
7426				return io.ErrUnexpectedEOF
7427			}
7428			b := dAtA[iNdEx]
7429			iNdEx++
7430			wire |= (uint64(b) & 0x7F) << shift
7431			if b < 0x80 {
7432				break
7433			}
7434		}
7435		fieldNum := int32(wire >> 3)
7436		wireType := int(wire & 0x7)
7437		if wireType == 4 {
7438			return fmt.Errorf("proto: IPBlock: wiretype end group for non-group")
7439		}
7440		if fieldNum <= 0 {
7441			return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire)
7442		}
7443		switch fieldNum {
7444		case 1:
7445			if wireType != 2 {
7446				return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType)
7447			}
7448			var stringLen uint64
7449			for shift := uint(0); ; shift += 7 {
7450				if shift >= 64 {
7451					return ErrIntOverflowGenerated
7452				}
7453				if iNdEx >= l {
7454					return io.ErrUnexpectedEOF
7455				}
7456				b := dAtA[iNdEx]
7457				iNdEx++
7458				stringLen |= (uint64(b) & 0x7F) << shift
7459				if b < 0x80 {
7460					break
7461				}
7462			}
7463			intStringLen := int(stringLen)
7464			if intStringLen < 0 {
7465				return ErrInvalidLengthGenerated
7466			}
7467			postIndex := iNdEx + intStringLen
7468			if postIndex > l {
7469				return io.ErrUnexpectedEOF
7470			}
7471			m.CIDR = string(dAtA[iNdEx:postIndex])
7472			iNdEx = postIndex
7473		case 2:
7474			if wireType != 2 {
7475				return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType)
7476			}
7477			var stringLen uint64
7478			for shift := uint(0); ; shift += 7 {
7479				if shift >= 64 {
7480					return ErrIntOverflowGenerated
7481				}
7482				if iNdEx >= l {
7483					return io.ErrUnexpectedEOF
7484				}
7485				b := dAtA[iNdEx]
7486				iNdEx++
7487				stringLen |= (uint64(b) & 0x7F) << shift
7488				if b < 0x80 {
7489					break
7490				}
7491			}
7492			intStringLen := int(stringLen)
7493			if intStringLen < 0 {
7494				return ErrInvalidLengthGenerated
7495			}
7496			postIndex := iNdEx + intStringLen
7497			if postIndex > l {
7498				return io.ErrUnexpectedEOF
7499			}
7500			m.Except = append(m.Except, string(dAtA[iNdEx:postIndex]))
7501			iNdEx = postIndex
7502		default:
7503			iNdEx = preIndex
7504			skippy, err := skipGenerated(dAtA[iNdEx:])
7505			if err != nil {
7506				return err
7507			}
7508			if skippy < 0 {
7509				return ErrInvalidLengthGenerated
7510			}
7511			if (iNdEx + skippy) > l {
7512				return io.ErrUnexpectedEOF
7513			}
7514			iNdEx += skippy
7515		}
7516	}
7517
7518	if iNdEx > l {
7519		return io.ErrUnexpectedEOF
7520	}
7521	return nil
7522}
7523func (m *Ingress) Unmarshal(dAtA []byte) error {
7524	l := len(dAtA)
7525	iNdEx := 0
7526	for iNdEx < l {
7527		preIndex := iNdEx
7528		var wire uint64
7529		for shift := uint(0); ; shift += 7 {
7530			if shift >= 64 {
7531				return ErrIntOverflowGenerated
7532			}
7533			if iNdEx >= l {
7534				return io.ErrUnexpectedEOF
7535			}
7536			b := dAtA[iNdEx]
7537			iNdEx++
7538			wire |= (uint64(b) & 0x7F) << shift
7539			if b < 0x80 {
7540				break
7541			}
7542		}
7543		fieldNum := int32(wire >> 3)
7544		wireType := int(wire & 0x7)
7545		if wireType == 4 {
7546			return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
7547		}
7548		if fieldNum <= 0 {
7549			return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
7550		}
7551		switch fieldNum {
7552		case 1:
7553			if wireType != 2 {
7554				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
7555			}
7556			var msglen int
7557			for shift := uint(0); ; shift += 7 {
7558				if shift >= 64 {
7559					return ErrIntOverflowGenerated
7560				}
7561				if iNdEx >= l {
7562					return io.ErrUnexpectedEOF
7563				}
7564				b := dAtA[iNdEx]
7565				iNdEx++
7566				msglen |= (int(b) & 0x7F) << shift
7567				if b < 0x80 {
7568					break
7569				}
7570			}
7571			if msglen < 0 {
7572				return ErrInvalidLengthGenerated
7573			}
7574			postIndex := iNdEx + msglen
7575			if postIndex > l {
7576				return io.ErrUnexpectedEOF
7577			}
7578			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7579				return err
7580			}
7581			iNdEx = postIndex
7582		case 2:
7583			if wireType != 2 {
7584				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
7585			}
7586			var msglen int
7587			for shift := uint(0); ; shift += 7 {
7588				if shift >= 64 {
7589					return ErrIntOverflowGenerated
7590				}
7591				if iNdEx >= l {
7592					return io.ErrUnexpectedEOF
7593				}
7594				b := dAtA[iNdEx]
7595				iNdEx++
7596				msglen |= (int(b) & 0x7F) << shift
7597				if b < 0x80 {
7598					break
7599				}
7600			}
7601			if msglen < 0 {
7602				return ErrInvalidLengthGenerated
7603			}
7604			postIndex := iNdEx + msglen
7605			if postIndex > l {
7606				return io.ErrUnexpectedEOF
7607			}
7608			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7609				return err
7610			}
7611			iNdEx = postIndex
7612		case 3:
7613			if wireType != 2 {
7614				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7615			}
7616			var msglen int
7617			for shift := uint(0); ; shift += 7 {
7618				if shift >= 64 {
7619					return ErrIntOverflowGenerated
7620				}
7621				if iNdEx >= l {
7622					return io.ErrUnexpectedEOF
7623				}
7624				b := dAtA[iNdEx]
7625				iNdEx++
7626				msglen |= (int(b) & 0x7F) << shift
7627				if b < 0x80 {
7628					break
7629				}
7630			}
7631			if msglen < 0 {
7632				return ErrInvalidLengthGenerated
7633			}
7634			postIndex := iNdEx + msglen
7635			if postIndex > l {
7636				return io.ErrUnexpectedEOF
7637			}
7638			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7639				return err
7640			}
7641			iNdEx = postIndex
7642		default:
7643			iNdEx = preIndex
7644			skippy, err := skipGenerated(dAtA[iNdEx:])
7645			if err != nil {
7646				return err
7647			}
7648			if skippy < 0 {
7649				return ErrInvalidLengthGenerated
7650			}
7651			if (iNdEx + skippy) > l {
7652				return io.ErrUnexpectedEOF
7653			}
7654			iNdEx += skippy
7655		}
7656	}
7657
7658	if iNdEx > l {
7659		return io.ErrUnexpectedEOF
7660	}
7661	return nil
7662}
7663func (m *IngressBackend) Unmarshal(dAtA []byte) error {
7664	l := len(dAtA)
7665	iNdEx := 0
7666	for iNdEx < l {
7667		preIndex := iNdEx
7668		var wire uint64
7669		for shift := uint(0); ; shift += 7 {
7670			if shift >= 64 {
7671				return ErrIntOverflowGenerated
7672			}
7673			if iNdEx >= l {
7674				return io.ErrUnexpectedEOF
7675			}
7676			b := dAtA[iNdEx]
7677			iNdEx++
7678			wire |= (uint64(b) & 0x7F) << shift
7679			if b < 0x80 {
7680				break
7681			}
7682		}
7683		fieldNum := int32(wire >> 3)
7684		wireType := int(wire & 0x7)
7685		if wireType == 4 {
7686			return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
7687		}
7688		if fieldNum <= 0 {
7689			return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
7690		}
7691		switch fieldNum {
7692		case 1:
7693			if wireType != 2 {
7694				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
7695			}
7696			var stringLen uint64
7697			for shift := uint(0); ; shift += 7 {
7698				if shift >= 64 {
7699					return ErrIntOverflowGenerated
7700				}
7701				if iNdEx >= l {
7702					return io.ErrUnexpectedEOF
7703				}
7704				b := dAtA[iNdEx]
7705				iNdEx++
7706				stringLen |= (uint64(b) & 0x7F) << shift
7707				if b < 0x80 {
7708					break
7709				}
7710			}
7711			intStringLen := int(stringLen)
7712			if intStringLen < 0 {
7713				return ErrInvalidLengthGenerated
7714			}
7715			postIndex := iNdEx + intStringLen
7716			if postIndex > l {
7717				return io.ErrUnexpectedEOF
7718			}
7719			m.ServiceName = string(dAtA[iNdEx:postIndex])
7720			iNdEx = postIndex
7721		case 2:
7722			if wireType != 2 {
7723				return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
7724			}
7725			var msglen int
7726			for shift := uint(0); ; shift += 7 {
7727				if shift >= 64 {
7728					return ErrIntOverflowGenerated
7729				}
7730				if iNdEx >= l {
7731					return io.ErrUnexpectedEOF
7732				}
7733				b := dAtA[iNdEx]
7734				iNdEx++
7735				msglen |= (int(b) & 0x7F) << shift
7736				if b < 0x80 {
7737					break
7738				}
7739			}
7740			if msglen < 0 {
7741				return ErrInvalidLengthGenerated
7742			}
7743			postIndex := iNdEx + msglen
7744			if postIndex > l {
7745				return io.ErrUnexpectedEOF
7746			}
7747			if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7748				return err
7749			}
7750			iNdEx = postIndex
7751		default:
7752			iNdEx = preIndex
7753			skippy, err := skipGenerated(dAtA[iNdEx:])
7754			if err != nil {
7755				return err
7756			}
7757			if skippy < 0 {
7758				return ErrInvalidLengthGenerated
7759			}
7760			if (iNdEx + skippy) > l {
7761				return io.ErrUnexpectedEOF
7762			}
7763			iNdEx += skippy
7764		}
7765	}
7766
7767	if iNdEx > l {
7768		return io.ErrUnexpectedEOF
7769	}
7770	return nil
7771}
7772func (m *IngressList) Unmarshal(dAtA []byte) error {
7773	l := len(dAtA)
7774	iNdEx := 0
7775	for iNdEx < l {
7776		preIndex := iNdEx
7777		var wire uint64
7778		for shift := uint(0); ; shift += 7 {
7779			if shift >= 64 {
7780				return ErrIntOverflowGenerated
7781			}
7782			if iNdEx >= l {
7783				return io.ErrUnexpectedEOF
7784			}
7785			b := dAtA[iNdEx]
7786			iNdEx++
7787			wire |= (uint64(b) & 0x7F) << shift
7788			if b < 0x80 {
7789				break
7790			}
7791		}
7792		fieldNum := int32(wire >> 3)
7793		wireType := int(wire & 0x7)
7794		if wireType == 4 {
7795			return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
7796		}
7797		if fieldNum <= 0 {
7798			return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
7799		}
7800		switch fieldNum {
7801		case 1:
7802			if wireType != 2 {
7803				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7804			}
7805			var msglen int
7806			for shift := uint(0); ; shift += 7 {
7807				if shift >= 64 {
7808					return ErrIntOverflowGenerated
7809				}
7810				if iNdEx >= l {
7811					return io.ErrUnexpectedEOF
7812				}
7813				b := dAtA[iNdEx]
7814				iNdEx++
7815				msglen |= (int(b) & 0x7F) << shift
7816				if b < 0x80 {
7817					break
7818				}
7819			}
7820			if msglen < 0 {
7821				return ErrInvalidLengthGenerated
7822			}
7823			postIndex := iNdEx + msglen
7824			if postIndex > l {
7825				return io.ErrUnexpectedEOF
7826			}
7827			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7828				return err
7829			}
7830			iNdEx = postIndex
7831		case 2:
7832			if wireType != 2 {
7833				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7834			}
7835			var msglen int
7836			for shift := uint(0); ; shift += 7 {
7837				if shift >= 64 {
7838					return ErrIntOverflowGenerated
7839				}
7840				if iNdEx >= l {
7841					return io.ErrUnexpectedEOF
7842				}
7843				b := dAtA[iNdEx]
7844				iNdEx++
7845				msglen |= (int(b) & 0x7F) << shift
7846				if b < 0x80 {
7847					break
7848				}
7849			}
7850			if msglen < 0 {
7851				return ErrInvalidLengthGenerated
7852			}
7853			postIndex := iNdEx + msglen
7854			if postIndex > l {
7855				return io.ErrUnexpectedEOF
7856			}
7857			m.Items = append(m.Items, Ingress{})
7858			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7859				return err
7860			}
7861			iNdEx = postIndex
7862		default:
7863			iNdEx = preIndex
7864			skippy, err := skipGenerated(dAtA[iNdEx:])
7865			if err != nil {
7866				return err
7867			}
7868			if skippy < 0 {
7869				return ErrInvalidLengthGenerated
7870			}
7871			if (iNdEx + skippy) > l {
7872				return io.ErrUnexpectedEOF
7873			}
7874			iNdEx += skippy
7875		}
7876	}
7877
7878	if iNdEx > l {
7879		return io.ErrUnexpectedEOF
7880	}
7881	return nil
7882}
7883func (m *IngressRule) Unmarshal(dAtA []byte) error {
7884	l := len(dAtA)
7885	iNdEx := 0
7886	for iNdEx < l {
7887		preIndex := iNdEx
7888		var wire uint64
7889		for shift := uint(0); ; shift += 7 {
7890			if shift >= 64 {
7891				return ErrIntOverflowGenerated
7892			}
7893			if iNdEx >= l {
7894				return io.ErrUnexpectedEOF
7895			}
7896			b := dAtA[iNdEx]
7897			iNdEx++
7898			wire |= (uint64(b) & 0x7F) << shift
7899			if b < 0x80 {
7900				break
7901			}
7902		}
7903		fieldNum := int32(wire >> 3)
7904		wireType := int(wire & 0x7)
7905		if wireType == 4 {
7906			return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
7907		}
7908		if fieldNum <= 0 {
7909			return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
7910		}
7911		switch fieldNum {
7912		case 1:
7913			if wireType != 2 {
7914				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
7915			}
7916			var stringLen uint64
7917			for shift := uint(0); ; shift += 7 {
7918				if shift >= 64 {
7919					return ErrIntOverflowGenerated
7920				}
7921				if iNdEx >= l {
7922					return io.ErrUnexpectedEOF
7923				}
7924				b := dAtA[iNdEx]
7925				iNdEx++
7926				stringLen |= (uint64(b) & 0x7F) << shift
7927				if b < 0x80 {
7928					break
7929				}
7930			}
7931			intStringLen := int(stringLen)
7932			if intStringLen < 0 {
7933				return ErrInvalidLengthGenerated
7934			}
7935			postIndex := iNdEx + intStringLen
7936			if postIndex > l {
7937				return io.ErrUnexpectedEOF
7938			}
7939			m.Host = string(dAtA[iNdEx:postIndex])
7940			iNdEx = postIndex
7941		case 2:
7942			if wireType != 2 {
7943				return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
7944			}
7945			var msglen int
7946			for shift := uint(0); ; shift += 7 {
7947				if shift >= 64 {
7948					return ErrIntOverflowGenerated
7949				}
7950				if iNdEx >= l {
7951					return io.ErrUnexpectedEOF
7952				}
7953				b := dAtA[iNdEx]
7954				iNdEx++
7955				msglen |= (int(b) & 0x7F) << shift
7956				if b < 0x80 {
7957					break
7958				}
7959			}
7960			if msglen < 0 {
7961				return ErrInvalidLengthGenerated
7962			}
7963			postIndex := iNdEx + msglen
7964			if postIndex > l {
7965				return io.ErrUnexpectedEOF
7966			}
7967			if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7968				return err
7969			}
7970			iNdEx = postIndex
7971		default:
7972			iNdEx = preIndex
7973			skippy, err := skipGenerated(dAtA[iNdEx:])
7974			if err != nil {
7975				return err
7976			}
7977			if skippy < 0 {
7978				return ErrInvalidLengthGenerated
7979			}
7980			if (iNdEx + skippy) > l {
7981				return io.ErrUnexpectedEOF
7982			}
7983			iNdEx += skippy
7984		}
7985	}
7986
7987	if iNdEx > l {
7988		return io.ErrUnexpectedEOF
7989	}
7990	return nil
7991}
7992func (m *IngressRuleValue) Unmarshal(dAtA []byte) error {
7993	l := len(dAtA)
7994	iNdEx := 0
7995	for iNdEx < l {
7996		preIndex := iNdEx
7997		var wire uint64
7998		for shift := uint(0); ; shift += 7 {
7999			if shift >= 64 {
8000				return ErrIntOverflowGenerated
8001			}
8002			if iNdEx >= l {
8003				return io.ErrUnexpectedEOF
8004			}
8005			b := dAtA[iNdEx]
8006			iNdEx++
8007			wire |= (uint64(b) & 0x7F) << shift
8008			if b < 0x80 {
8009				break
8010			}
8011		}
8012		fieldNum := int32(wire >> 3)
8013		wireType := int(wire & 0x7)
8014		if wireType == 4 {
8015			return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
8016		}
8017		if fieldNum <= 0 {
8018			return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
8019		}
8020		switch fieldNum {
8021		case 1:
8022			if wireType != 2 {
8023				return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
8024			}
8025			var msglen int
8026			for shift := uint(0); ; shift += 7 {
8027				if shift >= 64 {
8028					return ErrIntOverflowGenerated
8029				}
8030				if iNdEx >= l {
8031					return io.ErrUnexpectedEOF
8032				}
8033				b := dAtA[iNdEx]
8034				iNdEx++
8035				msglen |= (int(b) & 0x7F) << shift
8036				if b < 0x80 {
8037					break
8038				}
8039			}
8040			if msglen < 0 {
8041				return ErrInvalidLengthGenerated
8042			}
8043			postIndex := iNdEx + msglen
8044			if postIndex > l {
8045				return io.ErrUnexpectedEOF
8046			}
8047			if m.HTTP == nil {
8048				m.HTTP = &HTTPIngressRuleValue{}
8049			}
8050			if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8051				return err
8052			}
8053			iNdEx = postIndex
8054		default:
8055			iNdEx = preIndex
8056			skippy, err := skipGenerated(dAtA[iNdEx:])
8057			if err != nil {
8058				return err
8059			}
8060			if skippy < 0 {
8061				return ErrInvalidLengthGenerated
8062			}
8063			if (iNdEx + skippy) > l {
8064				return io.ErrUnexpectedEOF
8065			}
8066			iNdEx += skippy
8067		}
8068	}
8069
8070	if iNdEx > l {
8071		return io.ErrUnexpectedEOF
8072	}
8073	return nil
8074}
8075func (m *IngressSpec) Unmarshal(dAtA []byte) error {
8076	l := len(dAtA)
8077	iNdEx := 0
8078	for iNdEx < l {
8079		preIndex := iNdEx
8080		var wire uint64
8081		for shift := uint(0); ; shift += 7 {
8082			if shift >= 64 {
8083				return ErrIntOverflowGenerated
8084			}
8085			if iNdEx >= l {
8086				return io.ErrUnexpectedEOF
8087			}
8088			b := dAtA[iNdEx]
8089			iNdEx++
8090			wire |= (uint64(b) & 0x7F) << shift
8091			if b < 0x80 {
8092				break
8093			}
8094		}
8095		fieldNum := int32(wire >> 3)
8096		wireType := int(wire & 0x7)
8097		if wireType == 4 {
8098			return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
8099		}
8100		if fieldNum <= 0 {
8101			return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
8102		}
8103		switch fieldNum {
8104		case 1:
8105			if wireType != 2 {
8106				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
8107			}
8108			var msglen int
8109			for shift := uint(0); ; shift += 7 {
8110				if shift >= 64 {
8111					return ErrIntOverflowGenerated
8112				}
8113				if iNdEx >= l {
8114					return io.ErrUnexpectedEOF
8115				}
8116				b := dAtA[iNdEx]
8117				iNdEx++
8118				msglen |= (int(b) & 0x7F) << shift
8119				if b < 0x80 {
8120					break
8121				}
8122			}
8123			if msglen < 0 {
8124				return ErrInvalidLengthGenerated
8125			}
8126			postIndex := iNdEx + msglen
8127			if postIndex > l {
8128				return io.ErrUnexpectedEOF
8129			}
8130			if m.Backend == nil {
8131				m.Backend = &IngressBackend{}
8132			}
8133			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8134				return err
8135			}
8136			iNdEx = postIndex
8137		case 2:
8138			if wireType != 2 {
8139				return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
8140			}
8141			var msglen int
8142			for shift := uint(0); ; shift += 7 {
8143				if shift >= 64 {
8144					return ErrIntOverflowGenerated
8145				}
8146				if iNdEx >= l {
8147					return io.ErrUnexpectedEOF
8148				}
8149				b := dAtA[iNdEx]
8150				iNdEx++
8151				msglen |= (int(b) & 0x7F) << shift
8152				if b < 0x80 {
8153					break
8154				}
8155			}
8156			if msglen < 0 {
8157				return ErrInvalidLengthGenerated
8158			}
8159			postIndex := iNdEx + msglen
8160			if postIndex > l {
8161				return io.ErrUnexpectedEOF
8162			}
8163			m.TLS = append(m.TLS, IngressTLS{})
8164			if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8165				return err
8166			}
8167			iNdEx = postIndex
8168		case 3:
8169			if wireType != 2 {
8170				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
8171			}
8172			var msglen int
8173			for shift := uint(0); ; shift += 7 {
8174				if shift >= 64 {
8175					return ErrIntOverflowGenerated
8176				}
8177				if iNdEx >= l {
8178					return io.ErrUnexpectedEOF
8179				}
8180				b := dAtA[iNdEx]
8181				iNdEx++
8182				msglen |= (int(b) & 0x7F) << shift
8183				if b < 0x80 {
8184					break
8185				}
8186			}
8187			if msglen < 0 {
8188				return ErrInvalidLengthGenerated
8189			}
8190			postIndex := iNdEx + msglen
8191			if postIndex > l {
8192				return io.ErrUnexpectedEOF
8193			}
8194			m.Rules = append(m.Rules, IngressRule{})
8195			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8196				return err
8197			}
8198			iNdEx = postIndex
8199		default:
8200			iNdEx = preIndex
8201			skippy, err := skipGenerated(dAtA[iNdEx:])
8202			if err != nil {
8203				return err
8204			}
8205			if skippy < 0 {
8206				return ErrInvalidLengthGenerated
8207			}
8208			if (iNdEx + skippy) > l {
8209				return io.ErrUnexpectedEOF
8210			}
8211			iNdEx += skippy
8212		}
8213	}
8214
8215	if iNdEx > l {
8216		return io.ErrUnexpectedEOF
8217	}
8218	return nil
8219}
8220func (m *IngressStatus) Unmarshal(dAtA []byte) error {
8221	l := len(dAtA)
8222	iNdEx := 0
8223	for iNdEx < l {
8224		preIndex := iNdEx
8225		var wire uint64
8226		for shift := uint(0); ; shift += 7 {
8227			if shift >= 64 {
8228				return ErrIntOverflowGenerated
8229			}
8230			if iNdEx >= l {
8231				return io.ErrUnexpectedEOF
8232			}
8233			b := dAtA[iNdEx]
8234			iNdEx++
8235			wire |= (uint64(b) & 0x7F) << shift
8236			if b < 0x80 {
8237				break
8238			}
8239		}
8240		fieldNum := int32(wire >> 3)
8241		wireType := int(wire & 0x7)
8242		if wireType == 4 {
8243			return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
8244		}
8245		if fieldNum <= 0 {
8246			return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
8247		}
8248		switch fieldNum {
8249		case 1:
8250			if wireType != 2 {
8251				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
8252			}
8253			var msglen int
8254			for shift := uint(0); ; shift += 7 {
8255				if shift >= 64 {
8256					return ErrIntOverflowGenerated
8257				}
8258				if iNdEx >= l {
8259					return io.ErrUnexpectedEOF
8260				}
8261				b := dAtA[iNdEx]
8262				iNdEx++
8263				msglen |= (int(b) & 0x7F) << shift
8264				if b < 0x80 {
8265					break
8266				}
8267			}
8268			if msglen < 0 {
8269				return ErrInvalidLengthGenerated
8270			}
8271			postIndex := iNdEx + msglen
8272			if postIndex > l {
8273				return io.ErrUnexpectedEOF
8274			}
8275			if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8276				return err
8277			}
8278			iNdEx = postIndex
8279		default:
8280			iNdEx = preIndex
8281			skippy, err := skipGenerated(dAtA[iNdEx:])
8282			if err != nil {
8283				return err
8284			}
8285			if skippy < 0 {
8286				return ErrInvalidLengthGenerated
8287			}
8288			if (iNdEx + skippy) > l {
8289				return io.ErrUnexpectedEOF
8290			}
8291			iNdEx += skippy
8292		}
8293	}
8294
8295	if iNdEx > l {
8296		return io.ErrUnexpectedEOF
8297	}
8298	return nil
8299}
8300func (m *IngressTLS) Unmarshal(dAtA []byte) error {
8301	l := len(dAtA)
8302	iNdEx := 0
8303	for iNdEx < l {
8304		preIndex := iNdEx
8305		var wire uint64
8306		for shift := uint(0); ; shift += 7 {
8307			if shift >= 64 {
8308				return ErrIntOverflowGenerated
8309			}
8310			if iNdEx >= l {
8311				return io.ErrUnexpectedEOF
8312			}
8313			b := dAtA[iNdEx]
8314			iNdEx++
8315			wire |= (uint64(b) & 0x7F) << shift
8316			if b < 0x80 {
8317				break
8318			}
8319		}
8320		fieldNum := int32(wire >> 3)
8321		wireType := int(wire & 0x7)
8322		if wireType == 4 {
8323			return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
8324		}
8325		if fieldNum <= 0 {
8326			return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
8327		}
8328		switch fieldNum {
8329		case 1:
8330			if wireType != 2 {
8331				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
8332			}
8333			var stringLen uint64
8334			for shift := uint(0); ; shift += 7 {
8335				if shift >= 64 {
8336					return ErrIntOverflowGenerated
8337				}
8338				if iNdEx >= l {
8339					return io.ErrUnexpectedEOF
8340				}
8341				b := dAtA[iNdEx]
8342				iNdEx++
8343				stringLen |= (uint64(b) & 0x7F) << shift
8344				if b < 0x80 {
8345					break
8346				}
8347			}
8348			intStringLen := int(stringLen)
8349			if intStringLen < 0 {
8350				return ErrInvalidLengthGenerated
8351			}
8352			postIndex := iNdEx + intStringLen
8353			if postIndex > l {
8354				return io.ErrUnexpectedEOF
8355			}
8356			m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
8357			iNdEx = postIndex
8358		case 2:
8359			if wireType != 2 {
8360				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
8361			}
8362			var stringLen uint64
8363			for shift := uint(0); ; shift += 7 {
8364				if shift >= 64 {
8365					return ErrIntOverflowGenerated
8366				}
8367				if iNdEx >= l {
8368					return io.ErrUnexpectedEOF
8369				}
8370				b := dAtA[iNdEx]
8371				iNdEx++
8372				stringLen |= (uint64(b) & 0x7F) << shift
8373				if b < 0x80 {
8374					break
8375				}
8376			}
8377			intStringLen := int(stringLen)
8378			if intStringLen < 0 {
8379				return ErrInvalidLengthGenerated
8380			}
8381			postIndex := iNdEx + intStringLen
8382			if postIndex > l {
8383				return io.ErrUnexpectedEOF
8384			}
8385			m.SecretName = string(dAtA[iNdEx:postIndex])
8386			iNdEx = postIndex
8387		default:
8388			iNdEx = preIndex
8389			skippy, err := skipGenerated(dAtA[iNdEx:])
8390			if err != nil {
8391				return err
8392			}
8393			if skippy < 0 {
8394				return ErrInvalidLengthGenerated
8395			}
8396			if (iNdEx + skippy) > l {
8397				return io.ErrUnexpectedEOF
8398			}
8399			iNdEx += skippy
8400		}
8401	}
8402
8403	if iNdEx > l {
8404		return io.ErrUnexpectedEOF
8405	}
8406	return nil
8407}
8408func (m *NetworkPolicy) Unmarshal(dAtA []byte) error {
8409	l := len(dAtA)
8410	iNdEx := 0
8411	for iNdEx < l {
8412		preIndex := iNdEx
8413		var wire uint64
8414		for shift := uint(0); ; shift += 7 {
8415			if shift >= 64 {
8416				return ErrIntOverflowGenerated
8417			}
8418			if iNdEx >= l {
8419				return io.ErrUnexpectedEOF
8420			}
8421			b := dAtA[iNdEx]
8422			iNdEx++
8423			wire |= (uint64(b) & 0x7F) << shift
8424			if b < 0x80 {
8425				break
8426			}
8427		}
8428		fieldNum := int32(wire >> 3)
8429		wireType := int(wire & 0x7)
8430		if wireType == 4 {
8431			return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group")
8432		}
8433		if fieldNum <= 0 {
8434			return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
8435		}
8436		switch fieldNum {
8437		case 1:
8438			if wireType != 2 {
8439				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
8440			}
8441			var msglen int
8442			for shift := uint(0); ; shift += 7 {
8443				if shift >= 64 {
8444					return ErrIntOverflowGenerated
8445				}
8446				if iNdEx >= l {
8447					return io.ErrUnexpectedEOF
8448				}
8449				b := dAtA[iNdEx]
8450				iNdEx++
8451				msglen |= (int(b) & 0x7F) << shift
8452				if b < 0x80 {
8453					break
8454				}
8455			}
8456			if msglen < 0 {
8457				return ErrInvalidLengthGenerated
8458			}
8459			postIndex := iNdEx + msglen
8460			if postIndex > l {
8461				return io.ErrUnexpectedEOF
8462			}
8463			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8464				return err
8465			}
8466			iNdEx = postIndex
8467		case 2:
8468			if wireType != 2 {
8469				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
8470			}
8471			var msglen int
8472			for shift := uint(0); ; shift += 7 {
8473				if shift >= 64 {
8474					return ErrIntOverflowGenerated
8475				}
8476				if iNdEx >= l {
8477					return io.ErrUnexpectedEOF
8478				}
8479				b := dAtA[iNdEx]
8480				iNdEx++
8481				msglen |= (int(b) & 0x7F) << shift
8482				if b < 0x80 {
8483					break
8484				}
8485			}
8486			if msglen < 0 {
8487				return ErrInvalidLengthGenerated
8488			}
8489			postIndex := iNdEx + msglen
8490			if postIndex > l {
8491				return io.ErrUnexpectedEOF
8492			}
8493			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8494				return err
8495			}
8496			iNdEx = postIndex
8497		default:
8498			iNdEx = preIndex
8499			skippy, err := skipGenerated(dAtA[iNdEx:])
8500			if err != nil {
8501				return err
8502			}
8503			if skippy < 0 {
8504				return ErrInvalidLengthGenerated
8505			}
8506			if (iNdEx + skippy) > l {
8507				return io.ErrUnexpectedEOF
8508			}
8509			iNdEx += skippy
8510		}
8511	}
8512
8513	if iNdEx > l {
8514		return io.ErrUnexpectedEOF
8515	}
8516	return nil
8517}
8518func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error {
8519	l := len(dAtA)
8520	iNdEx := 0
8521	for iNdEx < l {
8522		preIndex := iNdEx
8523		var wire uint64
8524		for shift := uint(0); ; shift += 7 {
8525			if shift >= 64 {
8526				return ErrIntOverflowGenerated
8527			}
8528			if iNdEx >= l {
8529				return io.ErrUnexpectedEOF
8530			}
8531			b := dAtA[iNdEx]
8532			iNdEx++
8533			wire |= (uint64(b) & 0x7F) << shift
8534			if b < 0x80 {
8535				break
8536			}
8537		}
8538		fieldNum := int32(wire >> 3)
8539		wireType := int(wire & 0x7)
8540		if wireType == 4 {
8541			return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group")
8542		}
8543		if fieldNum <= 0 {
8544			return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8545		}
8546		switch fieldNum {
8547		case 1:
8548			if wireType != 2 {
8549				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8550			}
8551			var msglen int
8552			for shift := uint(0); ; shift += 7 {
8553				if shift >= 64 {
8554					return ErrIntOverflowGenerated
8555				}
8556				if iNdEx >= l {
8557					return io.ErrUnexpectedEOF
8558				}
8559				b := dAtA[iNdEx]
8560				iNdEx++
8561				msglen |= (int(b) & 0x7F) << shift
8562				if b < 0x80 {
8563					break
8564				}
8565			}
8566			if msglen < 0 {
8567				return ErrInvalidLengthGenerated
8568			}
8569			postIndex := iNdEx + msglen
8570			if postIndex > l {
8571				return io.ErrUnexpectedEOF
8572			}
8573			m.Ports = append(m.Ports, NetworkPolicyPort{})
8574			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8575				return err
8576			}
8577			iNdEx = postIndex
8578		case 2:
8579			if wireType != 2 {
8580				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
8581			}
8582			var msglen int
8583			for shift := uint(0); ; shift += 7 {
8584				if shift >= 64 {
8585					return ErrIntOverflowGenerated
8586				}
8587				if iNdEx >= l {
8588					return io.ErrUnexpectedEOF
8589				}
8590				b := dAtA[iNdEx]
8591				iNdEx++
8592				msglen |= (int(b) & 0x7F) << shift
8593				if b < 0x80 {
8594					break
8595				}
8596			}
8597			if msglen < 0 {
8598				return ErrInvalidLengthGenerated
8599			}
8600			postIndex := iNdEx + msglen
8601			if postIndex > l {
8602				return io.ErrUnexpectedEOF
8603			}
8604			m.To = append(m.To, NetworkPolicyPeer{})
8605			if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8606				return err
8607			}
8608			iNdEx = postIndex
8609		default:
8610			iNdEx = preIndex
8611			skippy, err := skipGenerated(dAtA[iNdEx:])
8612			if err != nil {
8613				return err
8614			}
8615			if skippy < 0 {
8616				return ErrInvalidLengthGenerated
8617			}
8618			if (iNdEx + skippy) > l {
8619				return io.ErrUnexpectedEOF
8620			}
8621			iNdEx += skippy
8622		}
8623	}
8624
8625	if iNdEx > l {
8626		return io.ErrUnexpectedEOF
8627	}
8628	return nil
8629}
8630func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error {
8631	l := len(dAtA)
8632	iNdEx := 0
8633	for iNdEx < l {
8634		preIndex := iNdEx
8635		var wire uint64
8636		for shift := uint(0); ; shift += 7 {
8637			if shift >= 64 {
8638				return ErrIntOverflowGenerated
8639			}
8640			if iNdEx >= l {
8641				return io.ErrUnexpectedEOF
8642			}
8643			b := dAtA[iNdEx]
8644			iNdEx++
8645			wire |= (uint64(b) & 0x7F) << shift
8646			if b < 0x80 {
8647				break
8648			}
8649		}
8650		fieldNum := int32(wire >> 3)
8651		wireType := int(wire & 0x7)
8652		if wireType == 4 {
8653			return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group")
8654		}
8655		if fieldNum <= 0 {
8656			return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
8657		}
8658		switch fieldNum {
8659		case 1:
8660			if wireType != 2 {
8661				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
8662			}
8663			var msglen int
8664			for shift := uint(0); ; shift += 7 {
8665				if shift >= 64 {
8666					return ErrIntOverflowGenerated
8667				}
8668				if iNdEx >= l {
8669					return io.ErrUnexpectedEOF
8670				}
8671				b := dAtA[iNdEx]
8672				iNdEx++
8673				msglen |= (int(b) & 0x7F) << shift
8674				if b < 0x80 {
8675					break
8676				}
8677			}
8678			if msglen < 0 {
8679				return ErrInvalidLengthGenerated
8680			}
8681			postIndex := iNdEx + msglen
8682			if postIndex > l {
8683				return io.ErrUnexpectedEOF
8684			}
8685			m.Ports = append(m.Ports, NetworkPolicyPort{})
8686			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8687				return err
8688			}
8689			iNdEx = postIndex
8690		case 2:
8691			if wireType != 2 {
8692				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
8693			}
8694			var msglen int
8695			for shift := uint(0); ; shift += 7 {
8696				if shift >= 64 {
8697					return ErrIntOverflowGenerated
8698				}
8699				if iNdEx >= l {
8700					return io.ErrUnexpectedEOF
8701				}
8702				b := dAtA[iNdEx]
8703				iNdEx++
8704				msglen |= (int(b) & 0x7F) << shift
8705				if b < 0x80 {
8706					break
8707				}
8708			}
8709			if msglen < 0 {
8710				return ErrInvalidLengthGenerated
8711			}
8712			postIndex := iNdEx + msglen
8713			if postIndex > l {
8714				return io.ErrUnexpectedEOF
8715			}
8716			m.From = append(m.From, NetworkPolicyPeer{})
8717			if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8718				return err
8719			}
8720			iNdEx = postIndex
8721		default:
8722			iNdEx = preIndex
8723			skippy, err := skipGenerated(dAtA[iNdEx:])
8724			if err != nil {
8725				return err
8726			}
8727			if skippy < 0 {
8728				return ErrInvalidLengthGenerated
8729			}
8730			if (iNdEx + skippy) > l {
8731				return io.ErrUnexpectedEOF
8732			}
8733			iNdEx += skippy
8734		}
8735	}
8736
8737	if iNdEx > l {
8738		return io.ErrUnexpectedEOF
8739	}
8740	return nil
8741}
8742func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error {
8743	l := len(dAtA)
8744	iNdEx := 0
8745	for iNdEx < l {
8746		preIndex := iNdEx
8747		var wire uint64
8748		for shift := uint(0); ; shift += 7 {
8749			if shift >= 64 {
8750				return ErrIntOverflowGenerated
8751			}
8752			if iNdEx >= l {
8753				return io.ErrUnexpectedEOF
8754			}
8755			b := dAtA[iNdEx]
8756			iNdEx++
8757			wire |= (uint64(b) & 0x7F) << shift
8758			if b < 0x80 {
8759				break
8760			}
8761		}
8762		fieldNum := int32(wire >> 3)
8763		wireType := int(wire & 0x7)
8764		if wireType == 4 {
8765			return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group")
8766		}
8767		if fieldNum <= 0 {
8768			return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
8769		}
8770		switch fieldNum {
8771		case 1:
8772			if wireType != 2 {
8773				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
8774			}
8775			var msglen int
8776			for shift := uint(0); ; shift += 7 {
8777				if shift >= 64 {
8778					return ErrIntOverflowGenerated
8779				}
8780				if iNdEx >= l {
8781					return io.ErrUnexpectedEOF
8782				}
8783				b := dAtA[iNdEx]
8784				iNdEx++
8785				msglen |= (int(b) & 0x7F) << shift
8786				if b < 0x80 {
8787					break
8788				}
8789			}
8790			if msglen < 0 {
8791				return ErrInvalidLengthGenerated
8792			}
8793			postIndex := iNdEx + msglen
8794			if postIndex > l {
8795				return io.ErrUnexpectedEOF
8796			}
8797			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8798				return err
8799			}
8800			iNdEx = postIndex
8801		case 2:
8802			if wireType != 2 {
8803				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
8804			}
8805			var msglen int
8806			for shift := uint(0); ; shift += 7 {
8807				if shift >= 64 {
8808					return ErrIntOverflowGenerated
8809				}
8810				if iNdEx >= l {
8811					return io.ErrUnexpectedEOF
8812				}
8813				b := dAtA[iNdEx]
8814				iNdEx++
8815				msglen |= (int(b) & 0x7F) << shift
8816				if b < 0x80 {
8817					break
8818				}
8819			}
8820			if msglen < 0 {
8821				return ErrInvalidLengthGenerated
8822			}
8823			postIndex := iNdEx + msglen
8824			if postIndex > l {
8825				return io.ErrUnexpectedEOF
8826			}
8827			m.Items = append(m.Items, NetworkPolicy{})
8828			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8829				return err
8830			}
8831			iNdEx = postIndex
8832		default:
8833			iNdEx = preIndex
8834			skippy, err := skipGenerated(dAtA[iNdEx:])
8835			if err != nil {
8836				return err
8837			}
8838			if skippy < 0 {
8839				return ErrInvalidLengthGenerated
8840			}
8841			if (iNdEx + skippy) > l {
8842				return io.ErrUnexpectedEOF
8843			}
8844			iNdEx += skippy
8845		}
8846	}
8847
8848	if iNdEx > l {
8849		return io.ErrUnexpectedEOF
8850	}
8851	return nil
8852}
8853func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error {
8854	l := len(dAtA)
8855	iNdEx := 0
8856	for iNdEx < l {
8857		preIndex := iNdEx
8858		var wire uint64
8859		for shift := uint(0); ; shift += 7 {
8860			if shift >= 64 {
8861				return ErrIntOverflowGenerated
8862			}
8863			if iNdEx >= l {
8864				return io.ErrUnexpectedEOF
8865			}
8866			b := dAtA[iNdEx]
8867			iNdEx++
8868			wire |= (uint64(b) & 0x7F) << shift
8869			if b < 0x80 {
8870				break
8871			}
8872		}
8873		fieldNum := int32(wire >> 3)
8874		wireType := int(wire & 0x7)
8875		if wireType == 4 {
8876			return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group")
8877		}
8878		if fieldNum <= 0 {
8879			return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire)
8880		}
8881		switch fieldNum {
8882		case 1:
8883			if wireType != 2 {
8884				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
8885			}
8886			var msglen int
8887			for shift := uint(0); ; shift += 7 {
8888				if shift >= 64 {
8889					return ErrIntOverflowGenerated
8890				}
8891				if iNdEx >= l {
8892					return io.ErrUnexpectedEOF
8893				}
8894				b := dAtA[iNdEx]
8895				iNdEx++
8896				msglen |= (int(b) & 0x7F) << shift
8897				if b < 0x80 {
8898					break
8899				}
8900			}
8901			if msglen < 0 {
8902				return ErrInvalidLengthGenerated
8903			}
8904			postIndex := iNdEx + msglen
8905			if postIndex > l {
8906				return io.ErrUnexpectedEOF
8907			}
8908			if m.PodSelector == nil {
8909				m.PodSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
8910			}
8911			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8912				return err
8913			}
8914			iNdEx = postIndex
8915		case 2:
8916			if wireType != 2 {
8917				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
8918			}
8919			var msglen int
8920			for shift := uint(0); ; shift += 7 {
8921				if shift >= 64 {
8922					return ErrIntOverflowGenerated
8923				}
8924				if iNdEx >= l {
8925					return io.ErrUnexpectedEOF
8926				}
8927				b := dAtA[iNdEx]
8928				iNdEx++
8929				msglen |= (int(b) & 0x7F) << shift
8930				if b < 0x80 {
8931					break
8932				}
8933			}
8934			if msglen < 0 {
8935				return ErrInvalidLengthGenerated
8936			}
8937			postIndex := iNdEx + msglen
8938			if postIndex > l {
8939				return io.ErrUnexpectedEOF
8940			}
8941			if m.NamespaceSelector == nil {
8942				m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
8943			}
8944			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8945				return err
8946			}
8947			iNdEx = postIndex
8948		case 3:
8949			if wireType != 2 {
8950				return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType)
8951			}
8952			var msglen int
8953			for shift := uint(0); ; shift += 7 {
8954				if shift >= 64 {
8955					return ErrIntOverflowGenerated
8956				}
8957				if iNdEx >= l {
8958					return io.ErrUnexpectedEOF
8959				}
8960				b := dAtA[iNdEx]
8961				iNdEx++
8962				msglen |= (int(b) & 0x7F) << shift
8963				if b < 0x80 {
8964					break
8965				}
8966			}
8967			if msglen < 0 {
8968				return ErrInvalidLengthGenerated
8969			}
8970			postIndex := iNdEx + msglen
8971			if postIndex > l {
8972				return io.ErrUnexpectedEOF
8973			}
8974			if m.IPBlock == nil {
8975				m.IPBlock = &IPBlock{}
8976			}
8977			if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8978				return err
8979			}
8980			iNdEx = postIndex
8981		default:
8982			iNdEx = preIndex
8983			skippy, err := skipGenerated(dAtA[iNdEx:])
8984			if err != nil {
8985				return err
8986			}
8987			if skippy < 0 {
8988				return ErrInvalidLengthGenerated
8989			}
8990			if (iNdEx + skippy) > l {
8991				return io.ErrUnexpectedEOF
8992			}
8993			iNdEx += skippy
8994		}
8995	}
8996
8997	if iNdEx > l {
8998		return io.ErrUnexpectedEOF
8999	}
9000	return nil
9001}
9002func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error {
9003	l := len(dAtA)
9004	iNdEx := 0
9005	for iNdEx < l {
9006		preIndex := iNdEx
9007		var wire uint64
9008		for shift := uint(0); ; shift += 7 {
9009			if shift >= 64 {
9010				return ErrIntOverflowGenerated
9011			}
9012			if iNdEx >= l {
9013				return io.ErrUnexpectedEOF
9014			}
9015			b := dAtA[iNdEx]
9016			iNdEx++
9017			wire |= (uint64(b) & 0x7F) << shift
9018			if b < 0x80 {
9019				break
9020			}
9021		}
9022		fieldNum := int32(wire >> 3)
9023		wireType := int(wire & 0x7)
9024		if wireType == 4 {
9025			return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group")
9026		}
9027		if fieldNum <= 0 {
9028			return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire)
9029		}
9030		switch fieldNum {
9031		case 1:
9032			if wireType != 2 {
9033				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
9034			}
9035			var stringLen uint64
9036			for shift := uint(0); ; shift += 7 {
9037				if shift >= 64 {
9038					return ErrIntOverflowGenerated
9039				}
9040				if iNdEx >= l {
9041					return io.ErrUnexpectedEOF
9042				}
9043				b := dAtA[iNdEx]
9044				iNdEx++
9045				stringLen |= (uint64(b) & 0x7F) << shift
9046				if b < 0x80 {
9047					break
9048				}
9049			}
9050			intStringLen := int(stringLen)
9051			if intStringLen < 0 {
9052				return ErrInvalidLengthGenerated
9053			}
9054			postIndex := iNdEx + intStringLen
9055			if postIndex > l {
9056				return io.ErrUnexpectedEOF
9057			}
9058			s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
9059			m.Protocol = &s
9060			iNdEx = postIndex
9061		case 2:
9062			if wireType != 2 {
9063				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
9064			}
9065			var msglen int
9066			for shift := uint(0); ; shift += 7 {
9067				if shift >= 64 {
9068					return ErrIntOverflowGenerated
9069				}
9070				if iNdEx >= l {
9071					return io.ErrUnexpectedEOF
9072				}
9073				b := dAtA[iNdEx]
9074				iNdEx++
9075				msglen |= (int(b) & 0x7F) << shift
9076				if b < 0x80 {
9077					break
9078				}
9079			}
9080			if msglen < 0 {
9081				return ErrInvalidLengthGenerated
9082			}
9083			postIndex := iNdEx + msglen
9084			if postIndex > l {
9085				return io.ErrUnexpectedEOF
9086			}
9087			if m.Port == nil {
9088				m.Port = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
9089			}
9090			if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9091				return err
9092			}
9093			iNdEx = postIndex
9094		default:
9095			iNdEx = preIndex
9096			skippy, err := skipGenerated(dAtA[iNdEx:])
9097			if err != nil {
9098				return err
9099			}
9100			if skippy < 0 {
9101				return ErrInvalidLengthGenerated
9102			}
9103			if (iNdEx + skippy) > l {
9104				return io.ErrUnexpectedEOF
9105			}
9106			iNdEx += skippy
9107		}
9108	}
9109
9110	if iNdEx > l {
9111		return io.ErrUnexpectedEOF
9112	}
9113	return nil
9114}
9115func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error {
9116	l := len(dAtA)
9117	iNdEx := 0
9118	for iNdEx < l {
9119		preIndex := iNdEx
9120		var wire uint64
9121		for shift := uint(0); ; shift += 7 {
9122			if shift >= 64 {
9123				return ErrIntOverflowGenerated
9124			}
9125			if iNdEx >= l {
9126				return io.ErrUnexpectedEOF
9127			}
9128			b := dAtA[iNdEx]
9129			iNdEx++
9130			wire |= (uint64(b) & 0x7F) << shift
9131			if b < 0x80 {
9132				break
9133			}
9134		}
9135		fieldNum := int32(wire >> 3)
9136		wireType := int(wire & 0x7)
9137		if wireType == 4 {
9138			return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group")
9139		}
9140		if fieldNum <= 0 {
9141			return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
9142		}
9143		switch fieldNum {
9144		case 1:
9145			if wireType != 2 {
9146				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
9147			}
9148			var msglen int
9149			for shift := uint(0); ; shift += 7 {
9150				if shift >= 64 {
9151					return ErrIntOverflowGenerated
9152				}
9153				if iNdEx >= l {
9154					return io.ErrUnexpectedEOF
9155				}
9156				b := dAtA[iNdEx]
9157				iNdEx++
9158				msglen |= (int(b) & 0x7F) << shift
9159				if b < 0x80 {
9160					break
9161				}
9162			}
9163			if msglen < 0 {
9164				return ErrInvalidLengthGenerated
9165			}
9166			postIndex := iNdEx + msglen
9167			if postIndex > l {
9168				return io.ErrUnexpectedEOF
9169			}
9170			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9171				return err
9172			}
9173			iNdEx = postIndex
9174		case 2:
9175			if wireType != 2 {
9176				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
9177			}
9178			var msglen int
9179			for shift := uint(0); ; shift += 7 {
9180				if shift >= 64 {
9181					return ErrIntOverflowGenerated
9182				}
9183				if iNdEx >= l {
9184					return io.ErrUnexpectedEOF
9185				}
9186				b := dAtA[iNdEx]
9187				iNdEx++
9188				msglen |= (int(b) & 0x7F) << shift
9189				if b < 0x80 {
9190					break
9191				}
9192			}
9193			if msglen < 0 {
9194				return ErrInvalidLengthGenerated
9195			}
9196			postIndex := iNdEx + msglen
9197			if postIndex > l {
9198				return io.ErrUnexpectedEOF
9199			}
9200			m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{})
9201			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9202				return err
9203			}
9204			iNdEx = postIndex
9205		case 3:
9206			if wireType != 2 {
9207				return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType)
9208			}
9209			var msglen int
9210			for shift := uint(0); ; shift += 7 {
9211				if shift >= 64 {
9212					return ErrIntOverflowGenerated
9213				}
9214				if iNdEx >= l {
9215					return io.ErrUnexpectedEOF
9216				}
9217				b := dAtA[iNdEx]
9218				iNdEx++
9219				msglen |= (int(b) & 0x7F) << shift
9220				if b < 0x80 {
9221					break
9222				}
9223			}
9224			if msglen < 0 {
9225				return ErrInvalidLengthGenerated
9226			}
9227			postIndex := iNdEx + msglen
9228			if postIndex > l {
9229				return io.ErrUnexpectedEOF
9230			}
9231			m.Egress = append(m.Egress, NetworkPolicyEgressRule{})
9232			if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9233				return err
9234			}
9235			iNdEx = postIndex
9236		case 4:
9237			if wireType != 2 {
9238				return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType)
9239			}
9240			var stringLen uint64
9241			for shift := uint(0); ; shift += 7 {
9242				if shift >= 64 {
9243					return ErrIntOverflowGenerated
9244				}
9245				if iNdEx >= l {
9246					return io.ErrUnexpectedEOF
9247				}
9248				b := dAtA[iNdEx]
9249				iNdEx++
9250				stringLen |= (uint64(b) & 0x7F) << shift
9251				if b < 0x80 {
9252					break
9253				}
9254			}
9255			intStringLen := int(stringLen)
9256			if intStringLen < 0 {
9257				return ErrInvalidLengthGenerated
9258			}
9259			postIndex := iNdEx + intStringLen
9260			if postIndex > l {
9261				return io.ErrUnexpectedEOF
9262			}
9263			m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex]))
9264			iNdEx = postIndex
9265		default:
9266			iNdEx = preIndex
9267			skippy, err := skipGenerated(dAtA[iNdEx:])
9268			if err != nil {
9269				return err
9270			}
9271			if skippy < 0 {
9272				return ErrInvalidLengthGenerated
9273			}
9274			if (iNdEx + skippy) > l {
9275				return io.ErrUnexpectedEOF
9276			}
9277			iNdEx += skippy
9278		}
9279	}
9280
9281	if iNdEx > l {
9282		return io.ErrUnexpectedEOF
9283	}
9284	return nil
9285}
9286func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error {
9287	l := len(dAtA)
9288	iNdEx := 0
9289	for iNdEx < l {
9290		preIndex := iNdEx
9291		var wire uint64
9292		for shift := uint(0); ; shift += 7 {
9293			if shift >= 64 {
9294				return ErrIntOverflowGenerated
9295			}
9296			if iNdEx >= l {
9297				return io.ErrUnexpectedEOF
9298			}
9299			b := dAtA[iNdEx]
9300			iNdEx++
9301			wire |= (uint64(b) & 0x7F) << shift
9302			if b < 0x80 {
9303				break
9304			}
9305		}
9306		fieldNum := int32(wire >> 3)
9307		wireType := int(wire & 0x7)
9308		if wireType == 4 {
9309			return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group")
9310		}
9311		if fieldNum <= 0 {
9312			return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
9313		}
9314		switch fieldNum {
9315		case 1:
9316			if wireType != 2 {
9317				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
9318			}
9319			var msglen int
9320			for shift := uint(0); ; shift += 7 {
9321				if shift >= 64 {
9322					return ErrIntOverflowGenerated
9323				}
9324				if iNdEx >= l {
9325					return io.ErrUnexpectedEOF
9326				}
9327				b := dAtA[iNdEx]
9328				iNdEx++
9329				msglen |= (int(b) & 0x7F) << shift
9330				if b < 0x80 {
9331					break
9332				}
9333			}
9334			if msglen < 0 {
9335				return ErrInvalidLengthGenerated
9336			}
9337			postIndex := iNdEx + msglen
9338			if postIndex > l {
9339				return io.ErrUnexpectedEOF
9340			}
9341			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9342				return err
9343			}
9344			iNdEx = postIndex
9345		case 2:
9346			if wireType != 2 {
9347				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
9348			}
9349			var msglen int
9350			for shift := uint(0); ; shift += 7 {
9351				if shift >= 64 {
9352					return ErrIntOverflowGenerated
9353				}
9354				if iNdEx >= l {
9355					return io.ErrUnexpectedEOF
9356				}
9357				b := dAtA[iNdEx]
9358				iNdEx++
9359				msglen |= (int(b) & 0x7F) << shift
9360				if b < 0x80 {
9361					break
9362				}
9363			}
9364			if msglen < 0 {
9365				return ErrInvalidLengthGenerated
9366			}
9367			postIndex := iNdEx + msglen
9368			if postIndex > l {
9369				return io.ErrUnexpectedEOF
9370			}
9371			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9372				return err
9373			}
9374			iNdEx = postIndex
9375		default:
9376			iNdEx = preIndex
9377			skippy, err := skipGenerated(dAtA[iNdEx:])
9378			if err != nil {
9379				return err
9380			}
9381			if skippy < 0 {
9382				return ErrInvalidLengthGenerated
9383			}
9384			if (iNdEx + skippy) > l {
9385				return io.ErrUnexpectedEOF
9386			}
9387			iNdEx += skippy
9388		}
9389	}
9390
9391	if iNdEx > l {
9392		return io.ErrUnexpectedEOF
9393	}
9394	return nil
9395}
9396func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error {
9397	l := len(dAtA)
9398	iNdEx := 0
9399	for iNdEx < l {
9400		preIndex := iNdEx
9401		var wire uint64
9402		for shift := uint(0); ; shift += 7 {
9403			if shift >= 64 {
9404				return ErrIntOverflowGenerated
9405			}
9406			if iNdEx >= l {
9407				return io.ErrUnexpectedEOF
9408			}
9409			b := dAtA[iNdEx]
9410			iNdEx++
9411			wire |= (uint64(b) & 0x7F) << shift
9412			if b < 0x80 {
9413				break
9414			}
9415		}
9416		fieldNum := int32(wire >> 3)
9417		wireType := int(wire & 0x7)
9418		if wireType == 4 {
9419			return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group")
9420		}
9421		if fieldNum <= 0 {
9422			return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
9423		}
9424		switch fieldNum {
9425		case 1:
9426			if wireType != 2 {
9427				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
9428			}
9429			var msglen int
9430			for shift := uint(0); ; shift += 7 {
9431				if shift >= 64 {
9432					return ErrIntOverflowGenerated
9433				}
9434				if iNdEx >= l {
9435					return io.ErrUnexpectedEOF
9436				}
9437				b := dAtA[iNdEx]
9438				iNdEx++
9439				msglen |= (int(b) & 0x7F) << shift
9440				if b < 0x80 {
9441					break
9442				}
9443			}
9444			if msglen < 0 {
9445				return ErrInvalidLengthGenerated
9446			}
9447			postIndex := iNdEx + msglen
9448			if postIndex > l {
9449				return io.ErrUnexpectedEOF
9450			}
9451			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9452				return err
9453			}
9454			iNdEx = postIndex
9455		case 2:
9456			if wireType != 2 {
9457				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
9458			}
9459			var msglen int
9460			for shift := uint(0); ; shift += 7 {
9461				if shift >= 64 {
9462					return ErrIntOverflowGenerated
9463				}
9464				if iNdEx >= l {
9465					return io.ErrUnexpectedEOF
9466				}
9467				b := dAtA[iNdEx]
9468				iNdEx++
9469				msglen |= (int(b) & 0x7F) << shift
9470				if b < 0x80 {
9471					break
9472				}
9473			}
9474			if msglen < 0 {
9475				return ErrInvalidLengthGenerated
9476			}
9477			postIndex := iNdEx + msglen
9478			if postIndex > l {
9479				return io.ErrUnexpectedEOF
9480			}
9481			m.Items = append(m.Items, PodSecurityPolicy{})
9482			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9483				return err
9484			}
9485			iNdEx = postIndex
9486		default:
9487			iNdEx = preIndex
9488			skippy, err := skipGenerated(dAtA[iNdEx:])
9489			if err != nil {
9490				return err
9491			}
9492			if skippy < 0 {
9493				return ErrInvalidLengthGenerated
9494			}
9495			if (iNdEx + skippy) > l {
9496				return io.ErrUnexpectedEOF
9497			}
9498			iNdEx += skippy
9499		}
9500	}
9501
9502	if iNdEx > l {
9503		return io.ErrUnexpectedEOF
9504	}
9505	return nil
9506}
9507func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error {
9508	l := len(dAtA)
9509	iNdEx := 0
9510	for iNdEx < l {
9511		preIndex := iNdEx
9512		var wire uint64
9513		for shift := uint(0); ; shift += 7 {
9514			if shift >= 64 {
9515				return ErrIntOverflowGenerated
9516			}
9517			if iNdEx >= l {
9518				return io.ErrUnexpectedEOF
9519			}
9520			b := dAtA[iNdEx]
9521			iNdEx++
9522			wire |= (uint64(b) & 0x7F) << shift
9523			if b < 0x80 {
9524				break
9525			}
9526		}
9527		fieldNum := int32(wire >> 3)
9528		wireType := int(wire & 0x7)
9529		if wireType == 4 {
9530			return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group")
9531		}
9532		if fieldNum <= 0 {
9533			return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
9534		}
9535		switch fieldNum {
9536		case 1:
9537			if wireType != 0 {
9538				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
9539			}
9540			var v int
9541			for shift := uint(0); ; shift += 7 {
9542				if shift >= 64 {
9543					return ErrIntOverflowGenerated
9544				}
9545				if iNdEx >= l {
9546					return io.ErrUnexpectedEOF
9547				}
9548				b := dAtA[iNdEx]
9549				iNdEx++
9550				v |= (int(b) & 0x7F) << shift
9551				if b < 0x80 {
9552					break
9553				}
9554			}
9555			m.Privileged = bool(v != 0)
9556		case 2:
9557			if wireType != 2 {
9558				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType)
9559			}
9560			var stringLen uint64
9561			for shift := uint(0); ; shift += 7 {
9562				if shift >= 64 {
9563					return ErrIntOverflowGenerated
9564				}
9565				if iNdEx >= l {
9566					return io.ErrUnexpectedEOF
9567				}
9568				b := dAtA[iNdEx]
9569				iNdEx++
9570				stringLen |= (uint64(b) & 0x7F) << shift
9571				if b < 0x80 {
9572					break
9573				}
9574			}
9575			intStringLen := int(stringLen)
9576			if intStringLen < 0 {
9577				return ErrInvalidLengthGenerated
9578			}
9579			postIndex := iNdEx + intStringLen
9580			if postIndex > l {
9581				return io.ErrUnexpectedEOF
9582			}
9583			m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9584			iNdEx = postIndex
9585		case 3:
9586			if wireType != 2 {
9587				return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType)
9588			}
9589			var stringLen uint64
9590			for shift := uint(0); ; shift += 7 {
9591				if shift >= 64 {
9592					return ErrIntOverflowGenerated
9593				}
9594				if iNdEx >= l {
9595					return io.ErrUnexpectedEOF
9596				}
9597				b := dAtA[iNdEx]
9598				iNdEx++
9599				stringLen |= (uint64(b) & 0x7F) << shift
9600				if b < 0x80 {
9601					break
9602				}
9603			}
9604			intStringLen := int(stringLen)
9605			if intStringLen < 0 {
9606				return ErrInvalidLengthGenerated
9607			}
9608			postIndex := iNdEx + intStringLen
9609			if postIndex > l {
9610				return io.ErrUnexpectedEOF
9611			}
9612			m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9613			iNdEx = postIndex
9614		case 4:
9615			if wireType != 2 {
9616				return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType)
9617			}
9618			var stringLen uint64
9619			for shift := uint(0); ; shift += 7 {
9620				if shift >= 64 {
9621					return ErrIntOverflowGenerated
9622				}
9623				if iNdEx >= l {
9624					return io.ErrUnexpectedEOF
9625				}
9626				b := dAtA[iNdEx]
9627				iNdEx++
9628				stringLen |= (uint64(b) & 0x7F) << shift
9629				if b < 0x80 {
9630					break
9631				}
9632			}
9633			intStringLen := int(stringLen)
9634			if intStringLen < 0 {
9635				return ErrInvalidLengthGenerated
9636			}
9637			postIndex := iNdEx + intStringLen
9638			if postIndex > l {
9639				return io.ErrUnexpectedEOF
9640			}
9641			m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex]))
9642			iNdEx = postIndex
9643		case 5:
9644			if wireType != 2 {
9645				return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType)
9646			}
9647			var stringLen uint64
9648			for shift := uint(0); ; shift += 7 {
9649				if shift >= 64 {
9650					return ErrIntOverflowGenerated
9651				}
9652				if iNdEx >= l {
9653					return io.ErrUnexpectedEOF
9654				}
9655				b := dAtA[iNdEx]
9656				iNdEx++
9657				stringLen |= (uint64(b) & 0x7F) << shift
9658				if b < 0x80 {
9659					break
9660				}
9661			}
9662			intStringLen := int(stringLen)
9663			if intStringLen < 0 {
9664				return ErrInvalidLengthGenerated
9665			}
9666			postIndex := iNdEx + intStringLen
9667			if postIndex > l {
9668				return io.ErrUnexpectedEOF
9669			}
9670			m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex]))
9671			iNdEx = postIndex
9672		case 6:
9673			if wireType != 0 {
9674				return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType)
9675			}
9676			var v int
9677			for shift := uint(0); ; shift += 7 {
9678				if shift >= 64 {
9679					return ErrIntOverflowGenerated
9680				}
9681				if iNdEx >= l {
9682					return io.ErrUnexpectedEOF
9683				}
9684				b := dAtA[iNdEx]
9685				iNdEx++
9686				v |= (int(b) & 0x7F) << shift
9687				if b < 0x80 {
9688					break
9689				}
9690			}
9691			m.HostNetwork = bool(v != 0)
9692		case 7:
9693			if wireType != 2 {
9694				return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType)
9695			}
9696			var msglen int
9697			for shift := uint(0); ; shift += 7 {
9698				if shift >= 64 {
9699					return ErrIntOverflowGenerated
9700				}
9701				if iNdEx >= l {
9702					return io.ErrUnexpectedEOF
9703				}
9704				b := dAtA[iNdEx]
9705				iNdEx++
9706				msglen |= (int(b) & 0x7F) << shift
9707				if b < 0x80 {
9708					break
9709				}
9710			}
9711			if msglen < 0 {
9712				return ErrInvalidLengthGenerated
9713			}
9714			postIndex := iNdEx + msglen
9715			if postIndex > l {
9716				return io.ErrUnexpectedEOF
9717			}
9718			m.HostPorts = append(m.HostPorts, HostPortRange{})
9719			if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9720				return err
9721			}
9722			iNdEx = postIndex
9723		case 8:
9724			if wireType != 0 {
9725				return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType)
9726			}
9727			var v int
9728			for shift := uint(0); ; shift += 7 {
9729				if shift >= 64 {
9730					return ErrIntOverflowGenerated
9731				}
9732				if iNdEx >= l {
9733					return io.ErrUnexpectedEOF
9734				}
9735				b := dAtA[iNdEx]
9736				iNdEx++
9737				v |= (int(b) & 0x7F) << shift
9738				if b < 0x80 {
9739					break
9740				}
9741			}
9742			m.HostPID = bool(v != 0)
9743		case 9:
9744			if wireType != 0 {
9745				return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType)
9746			}
9747			var v int
9748			for shift := uint(0); ; shift += 7 {
9749				if shift >= 64 {
9750					return ErrIntOverflowGenerated
9751				}
9752				if iNdEx >= l {
9753					return io.ErrUnexpectedEOF
9754				}
9755				b := dAtA[iNdEx]
9756				iNdEx++
9757				v |= (int(b) & 0x7F) << shift
9758				if b < 0x80 {
9759					break
9760				}
9761			}
9762			m.HostIPC = bool(v != 0)
9763		case 10:
9764			if wireType != 2 {
9765				return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType)
9766			}
9767			var msglen 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				msglen |= (int(b) & 0x7F) << shift
9778				if b < 0x80 {
9779					break
9780				}
9781			}
9782			if msglen < 0 {
9783				return ErrInvalidLengthGenerated
9784			}
9785			postIndex := iNdEx + msglen
9786			if postIndex > l {
9787				return io.ErrUnexpectedEOF
9788			}
9789			if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9790				return err
9791			}
9792			iNdEx = postIndex
9793		case 11:
9794			if wireType != 2 {
9795				return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType)
9796			}
9797			var msglen int
9798			for shift := uint(0); ; shift += 7 {
9799				if shift >= 64 {
9800					return ErrIntOverflowGenerated
9801				}
9802				if iNdEx >= l {
9803					return io.ErrUnexpectedEOF
9804				}
9805				b := dAtA[iNdEx]
9806				iNdEx++
9807				msglen |= (int(b) & 0x7F) << shift
9808				if b < 0x80 {
9809					break
9810				}
9811			}
9812			if msglen < 0 {
9813				return ErrInvalidLengthGenerated
9814			}
9815			postIndex := iNdEx + msglen
9816			if postIndex > l {
9817				return io.ErrUnexpectedEOF
9818			}
9819			if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9820				return err
9821			}
9822			iNdEx = postIndex
9823		case 12:
9824			if wireType != 2 {
9825				return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType)
9826			}
9827			var msglen int
9828			for shift := uint(0); ; shift += 7 {
9829				if shift >= 64 {
9830					return ErrIntOverflowGenerated
9831				}
9832				if iNdEx >= l {
9833					return io.ErrUnexpectedEOF
9834				}
9835				b := dAtA[iNdEx]
9836				iNdEx++
9837				msglen |= (int(b) & 0x7F) << shift
9838				if b < 0x80 {
9839					break
9840				}
9841			}
9842			if msglen < 0 {
9843				return ErrInvalidLengthGenerated
9844			}
9845			postIndex := iNdEx + msglen
9846			if postIndex > l {
9847				return io.ErrUnexpectedEOF
9848			}
9849			if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9850				return err
9851			}
9852			iNdEx = postIndex
9853		case 13:
9854			if wireType != 2 {
9855				return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType)
9856			}
9857			var msglen int
9858			for shift := uint(0); ; shift += 7 {
9859				if shift >= 64 {
9860					return ErrIntOverflowGenerated
9861				}
9862				if iNdEx >= l {
9863					return io.ErrUnexpectedEOF
9864				}
9865				b := dAtA[iNdEx]
9866				iNdEx++
9867				msglen |= (int(b) & 0x7F) << shift
9868				if b < 0x80 {
9869					break
9870				}
9871			}
9872			if msglen < 0 {
9873				return ErrInvalidLengthGenerated
9874			}
9875			postIndex := iNdEx + msglen
9876			if postIndex > l {
9877				return io.ErrUnexpectedEOF
9878			}
9879			if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9880				return err
9881			}
9882			iNdEx = postIndex
9883		case 14:
9884			if wireType != 0 {
9885				return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType)
9886			}
9887			var v int
9888			for shift := uint(0); ; shift += 7 {
9889				if shift >= 64 {
9890					return ErrIntOverflowGenerated
9891				}
9892				if iNdEx >= l {
9893					return io.ErrUnexpectedEOF
9894				}
9895				b := dAtA[iNdEx]
9896				iNdEx++
9897				v |= (int(b) & 0x7F) << shift
9898				if b < 0x80 {
9899					break
9900				}
9901			}
9902			m.ReadOnlyRootFilesystem = bool(v != 0)
9903		case 15:
9904			if wireType != 0 {
9905				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType)
9906			}
9907			var v int
9908			for shift := uint(0); ; shift += 7 {
9909				if shift >= 64 {
9910					return ErrIntOverflowGenerated
9911				}
9912				if iNdEx >= l {
9913					return io.ErrUnexpectedEOF
9914				}
9915				b := dAtA[iNdEx]
9916				iNdEx++
9917				v |= (int(b) & 0x7F) << shift
9918				if b < 0x80 {
9919					break
9920				}
9921			}
9922			b := bool(v != 0)
9923			m.DefaultAllowPrivilegeEscalation = &b
9924		case 16:
9925			if wireType != 0 {
9926				return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType)
9927			}
9928			var v int
9929			for shift := uint(0); ; shift += 7 {
9930				if shift >= 64 {
9931					return ErrIntOverflowGenerated
9932				}
9933				if iNdEx >= l {
9934					return io.ErrUnexpectedEOF
9935				}
9936				b := dAtA[iNdEx]
9937				iNdEx++
9938				v |= (int(b) & 0x7F) << shift
9939				if b < 0x80 {
9940					break
9941				}
9942			}
9943			b := bool(v != 0)
9944			m.AllowPrivilegeEscalation = &b
9945		case 17:
9946			if wireType != 2 {
9947				return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType)
9948			}
9949			var msglen int
9950			for shift := uint(0); ; shift += 7 {
9951				if shift >= 64 {
9952					return ErrIntOverflowGenerated
9953				}
9954				if iNdEx >= l {
9955					return io.ErrUnexpectedEOF
9956				}
9957				b := dAtA[iNdEx]
9958				iNdEx++
9959				msglen |= (int(b) & 0x7F) << shift
9960				if b < 0x80 {
9961					break
9962				}
9963			}
9964			if msglen < 0 {
9965				return ErrInvalidLengthGenerated
9966			}
9967			postIndex := iNdEx + msglen
9968			if postIndex > l {
9969				return io.ErrUnexpectedEOF
9970			}
9971			m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{})
9972			if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
9973				return err
9974			}
9975			iNdEx = postIndex
9976		case 18:
9977			if wireType != 2 {
9978				return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType)
9979			}
9980			var msglen int
9981			for shift := uint(0); ; shift += 7 {
9982				if shift >= 64 {
9983					return ErrIntOverflowGenerated
9984				}
9985				if iNdEx >= l {
9986					return io.ErrUnexpectedEOF
9987				}
9988				b := dAtA[iNdEx]
9989				iNdEx++
9990				msglen |= (int(b) & 0x7F) << shift
9991				if b < 0x80 {
9992					break
9993				}
9994			}
9995			if msglen < 0 {
9996				return ErrInvalidLengthGenerated
9997			}
9998			postIndex := iNdEx + msglen
9999			if postIndex > l {
10000				return io.ErrUnexpectedEOF
10001			}
10002			m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{})
10003			if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10004				return err
10005			}
10006			iNdEx = postIndex
10007		case 19:
10008			if wireType != 2 {
10009				return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType)
10010			}
10011			var stringLen uint64
10012			for shift := uint(0); ; shift += 7 {
10013				if shift >= 64 {
10014					return ErrIntOverflowGenerated
10015				}
10016				if iNdEx >= l {
10017					return io.ErrUnexpectedEOF
10018				}
10019				b := dAtA[iNdEx]
10020				iNdEx++
10021				stringLen |= (uint64(b) & 0x7F) << shift
10022				if b < 0x80 {
10023					break
10024				}
10025			}
10026			intStringLen := int(stringLen)
10027			if intStringLen < 0 {
10028				return ErrInvalidLengthGenerated
10029			}
10030			postIndex := iNdEx + intStringLen
10031			if postIndex > l {
10032				return io.ErrUnexpectedEOF
10033			}
10034			m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex]))
10035			iNdEx = postIndex
10036		case 20:
10037			if wireType != 2 {
10038				return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType)
10039			}
10040			var stringLen uint64
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				stringLen |= (uint64(b) & 0x7F) << shift
10051				if b < 0x80 {
10052					break
10053				}
10054			}
10055			intStringLen := int(stringLen)
10056			if intStringLen < 0 {
10057				return ErrInvalidLengthGenerated
10058			}
10059			postIndex := iNdEx + intStringLen
10060			if postIndex > l {
10061				return io.ErrUnexpectedEOF
10062			}
10063			m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex]))
10064			iNdEx = postIndex
10065		case 21:
10066			if wireType != 2 {
10067				return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType)
10068			}
10069			var stringLen uint64
10070			for shift := uint(0); ; shift += 7 {
10071				if shift >= 64 {
10072					return ErrIntOverflowGenerated
10073				}
10074				if iNdEx >= l {
10075					return io.ErrUnexpectedEOF
10076				}
10077				b := dAtA[iNdEx]
10078				iNdEx++
10079				stringLen |= (uint64(b) & 0x7F) << shift
10080				if b < 0x80 {
10081					break
10082				}
10083			}
10084			intStringLen := int(stringLen)
10085			if intStringLen < 0 {
10086				return ErrInvalidLengthGenerated
10087			}
10088			postIndex := iNdEx + intStringLen
10089			if postIndex > l {
10090				return io.ErrUnexpectedEOF
10091			}
10092			m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex]))
10093			iNdEx = postIndex
10094		case 22:
10095			if wireType != 2 {
10096				return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType)
10097			}
10098			var msglen int
10099			for shift := uint(0); ; shift += 7 {
10100				if shift >= 64 {
10101					return ErrIntOverflowGenerated
10102				}
10103				if iNdEx >= l {
10104					return io.ErrUnexpectedEOF
10105				}
10106				b := dAtA[iNdEx]
10107				iNdEx++
10108				msglen |= (int(b) & 0x7F) << shift
10109				if b < 0x80 {
10110					break
10111				}
10112			}
10113			if msglen < 0 {
10114				return ErrInvalidLengthGenerated
10115			}
10116			postIndex := iNdEx + msglen
10117			if postIndex > l {
10118				return io.ErrUnexpectedEOF
10119			}
10120			if m.RunAsGroup == nil {
10121				m.RunAsGroup = &RunAsGroupStrategyOptions{}
10122			}
10123			if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10124				return err
10125			}
10126			iNdEx = postIndex
10127		case 23:
10128			if wireType != 2 {
10129				return fmt.Errorf("proto: wrong wireType = %d for field AllowedCSIDrivers", wireType)
10130			}
10131			var msglen int
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				msglen |= (int(b) & 0x7F) << shift
10142				if b < 0x80 {
10143					break
10144				}
10145			}
10146			if msglen < 0 {
10147				return ErrInvalidLengthGenerated
10148			}
10149			postIndex := iNdEx + msglen
10150			if postIndex > l {
10151				return io.ErrUnexpectedEOF
10152			}
10153			m.AllowedCSIDrivers = append(m.AllowedCSIDrivers, AllowedCSIDriver{})
10154			if err := m.AllowedCSIDrivers[len(m.AllowedCSIDrivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10155				return err
10156			}
10157			iNdEx = postIndex
10158		default:
10159			iNdEx = preIndex
10160			skippy, err := skipGenerated(dAtA[iNdEx:])
10161			if err != nil {
10162				return err
10163			}
10164			if skippy < 0 {
10165				return ErrInvalidLengthGenerated
10166			}
10167			if (iNdEx + skippy) > l {
10168				return io.ErrUnexpectedEOF
10169			}
10170			iNdEx += skippy
10171		}
10172	}
10173
10174	if iNdEx > l {
10175		return io.ErrUnexpectedEOF
10176	}
10177	return nil
10178}
10179func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
10180	l := len(dAtA)
10181	iNdEx := 0
10182	for iNdEx < l {
10183		preIndex := iNdEx
10184		var wire uint64
10185		for shift := uint(0); ; shift += 7 {
10186			if shift >= 64 {
10187				return ErrIntOverflowGenerated
10188			}
10189			if iNdEx >= l {
10190				return io.ErrUnexpectedEOF
10191			}
10192			b := dAtA[iNdEx]
10193			iNdEx++
10194			wire |= (uint64(b) & 0x7F) << shift
10195			if b < 0x80 {
10196				break
10197			}
10198		}
10199		fieldNum := int32(wire >> 3)
10200		wireType := int(wire & 0x7)
10201		if wireType == 4 {
10202			return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
10203		}
10204		if fieldNum <= 0 {
10205			return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
10206		}
10207		switch fieldNum {
10208		case 1:
10209			if wireType != 2 {
10210				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
10211			}
10212			var msglen int
10213			for shift := uint(0); ; shift += 7 {
10214				if shift >= 64 {
10215					return ErrIntOverflowGenerated
10216				}
10217				if iNdEx >= l {
10218					return io.ErrUnexpectedEOF
10219				}
10220				b := dAtA[iNdEx]
10221				iNdEx++
10222				msglen |= (int(b) & 0x7F) << shift
10223				if b < 0x80 {
10224					break
10225				}
10226			}
10227			if msglen < 0 {
10228				return ErrInvalidLengthGenerated
10229			}
10230			postIndex := iNdEx + msglen
10231			if postIndex > l {
10232				return io.ErrUnexpectedEOF
10233			}
10234			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10235				return err
10236			}
10237			iNdEx = postIndex
10238		case 2:
10239			if wireType != 2 {
10240				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
10241			}
10242			var msglen int
10243			for shift := uint(0); ; shift += 7 {
10244				if shift >= 64 {
10245					return ErrIntOverflowGenerated
10246				}
10247				if iNdEx >= l {
10248					return io.ErrUnexpectedEOF
10249				}
10250				b := dAtA[iNdEx]
10251				iNdEx++
10252				msglen |= (int(b) & 0x7F) << shift
10253				if b < 0x80 {
10254					break
10255				}
10256			}
10257			if msglen < 0 {
10258				return ErrInvalidLengthGenerated
10259			}
10260			postIndex := iNdEx + msglen
10261			if postIndex > l {
10262				return io.ErrUnexpectedEOF
10263			}
10264			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10265				return err
10266			}
10267			iNdEx = postIndex
10268		case 3:
10269			if wireType != 2 {
10270				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10271			}
10272			var msglen int
10273			for shift := uint(0); ; shift += 7 {
10274				if shift >= 64 {
10275					return ErrIntOverflowGenerated
10276				}
10277				if iNdEx >= l {
10278					return io.ErrUnexpectedEOF
10279				}
10280				b := dAtA[iNdEx]
10281				iNdEx++
10282				msglen |= (int(b) & 0x7F) << shift
10283				if b < 0x80 {
10284					break
10285				}
10286			}
10287			if msglen < 0 {
10288				return ErrInvalidLengthGenerated
10289			}
10290			postIndex := iNdEx + msglen
10291			if postIndex > l {
10292				return io.ErrUnexpectedEOF
10293			}
10294			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10295				return err
10296			}
10297			iNdEx = postIndex
10298		default:
10299			iNdEx = preIndex
10300			skippy, err := skipGenerated(dAtA[iNdEx:])
10301			if err != nil {
10302				return err
10303			}
10304			if skippy < 0 {
10305				return ErrInvalidLengthGenerated
10306			}
10307			if (iNdEx + skippy) > l {
10308				return io.ErrUnexpectedEOF
10309			}
10310			iNdEx += skippy
10311		}
10312	}
10313
10314	if iNdEx > l {
10315		return io.ErrUnexpectedEOF
10316	}
10317	return nil
10318}
10319func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
10320	l := len(dAtA)
10321	iNdEx := 0
10322	for iNdEx < l {
10323		preIndex := iNdEx
10324		var wire uint64
10325		for shift := uint(0); ; shift += 7 {
10326			if shift >= 64 {
10327				return ErrIntOverflowGenerated
10328			}
10329			if iNdEx >= l {
10330				return io.ErrUnexpectedEOF
10331			}
10332			b := dAtA[iNdEx]
10333			iNdEx++
10334			wire |= (uint64(b) & 0x7F) << shift
10335			if b < 0x80 {
10336				break
10337			}
10338		}
10339		fieldNum := int32(wire >> 3)
10340		wireType := int(wire & 0x7)
10341		if wireType == 4 {
10342			return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
10343		}
10344		if fieldNum <= 0 {
10345			return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
10346		}
10347		switch fieldNum {
10348		case 1:
10349			if wireType != 2 {
10350				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
10351			}
10352			var stringLen uint64
10353			for shift := uint(0); ; shift += 7 {
10354				if shift >= 64 {
10355					return ErrIntOverflowGenerated
10356				}
10357				if iNdEx >= l {
10358					return io.ErrUnexpectedEOF
10359				}
10360				b := dAtA[iNdEx]
10361				iNdEx++
10362				stringLen |= (uint64(b) & 0x7F) << shift
10363				if b < 0x80 {
10364					break
10365				}
10366			}
10367			intStringLen := int(stringLen)
10368			if intStringLen < 0 {
10369				return ErrInvalidLengthGenerated
10370			}
10371			postIndex := iNdEx + intStringLen
10372			if postIndex > l {
10373				return io.ErrUnexpectedEOF
10374			}
10375			m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
10376			iNdEx = postIndex
10377		case 2:
10378			if wireType != 2 {
10379				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
10380			}
10381			var stringLen uint64
10382			for shift := uint(0); ; shift += 7 {
10383				if shift >= 64 {
10384					return ErrIntOverflowGenerated
10385				}
10386				if iNdEx >= l {
10387					return io.ErrUnexpectedEOF
10388				}
10389				b := dAtA[iNdEx]
10390				iNdEx++
10391				stringLen |= (uint64(b) & 0x7F) << shift
10392				if b < 0x80 {
10393					break
10394				}
10395			}
10396			intStringLen := int(stringLen)
10397			if intStringLen < 0 {
10398				return ErrInvalidLengthGenerated
10399			}
10400			postIndex := iNdEx + intStringLen
10401			if postIndex > l {
10402				return io.ErrUnexpectedEOF
10403			}
10404			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
10405			iNdEx = postIndex
10406		case 3:
10407			if wireType != 2 {
10408				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
10409			}
10410			var msglen int
10411			for shift := uint(0); ; shift += 7 {
10412				if shift >= 64 {
10413					return ErrIntOverflowGenerated
10414				}
10415				if iNdEx >= l {
10416					return io.ErrUnexpectedEOF
10417				}
10418				b := dAtA[iNdEx]
10419				iNdEx++
10420				msglen |= (int(b) & 0x7F) << shift
10421				if b < 0x80 {
10422					break
10423				}
10424			}
10425			if msglen < 0 {
10426				return ErrInvalidLengthGenerated
10427			}
10428			postIndex := iNdEx + msglen
10429			if postIndex > l {
10430				return io.ErrUnexpectedEOF
10431			}
10432			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10433				return err
10434			}
10435			iNdEx = postIndex
10436		case 4:
10437			if wireType != 2 {
10438				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
10439			}
10440			var stringLen uint64
10441			for shift := uint(0); ; shift += 7 {
10442				if shift >= 64 {
10443					return ErrIntOverflowGenerated
10444				}
10445				if iNdEx >= l {
10446					return io.ErrUnexpectedEOF
10447				}
10448				b := dAtA[iNdEx]
10449				iNdEx++
10450				stringLen |= (uint64(b) & 0x7F) << shift
10451				if b < 0x80 {
10452					break
10453				}
10454			}
10455			intStringLen := int(stringLen)
10456			if intStringLen < 0 {
10457				return ErrInvalidLengthGenerated
10458			}
10459			postIndex := iNdEx + intStringLen
10460			if postIndex > l {
10461				return io.ErrUnexpectedEOF
10462			}
10463			m.Reason = string(dAtA[iNdEx:postIndex])
10464			iNdEx = postIndex
10465		case 5:
10466			if wireType != 2 {
10467				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
10468			}
10469			var stringLen uint64
10470			for shift := uint(0); ; shift += 7 {
10471				if shift >= 64 {
10472					return ErrIntOverflowGenerated
10473				}
10474				if iNdEx >= l {
10475					return io.ErrUnexpectedEOF
10476				}
10477				b := dAtA[iNdEx]
10478				iNdEx++
10479				stringLen |= (uint64(b) & 0x7F) << shift
10480				if b < 0x80 {
10481					break
10482				}
10483			}
10484			intStringLen := int(stringLen)
10485			if intStringLen < 0 {
10486				return ErrInvalidLengthGenerated
10487			}
10488			postIndex := iNdEx + intStringLen
10489			if postIndex > l {
10490				return io.ErrUnexpectedEOF
10491			}
10492			m.Message = string(dAtA[iNdEx:postIndex])
10493			iNdEx = postIndex
10494		default:
10495			iNdEx = preIndex
10496			skippy, err := skipGenerated(dAtA[iNdEx:])
10497			if err != nil {
10498				return err
10499			}
10500			if skippy < 0 {
10501				return ErrInvalidLengthGenerated
10502			}
10503			if (iNdEx + skippy) > l {
10504				return io.ErrUnexpectedEOF
10505			}
10506			iNdEx += skippy
10507		}
10508	}
10509
10510	if iNdEx > l {
10511		return io.ErrUnexpectedEOF
10512	}
10513	return nil
10514}
10515func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
10516	l := len(dAtA)
10517	iNdEx := 0
10518	for iNdEx < l {
10519		preIndex := iNdEx
10520		var wire uint64
10521		for shift := uint(0); ; shift += 7 {
10522			if shift >= 64 {
10523				return ErrIntOverflowGenerated
10524			}
10525			if iNdEx >= l {
10526				return io.ErrUnexpectedEOF
10527			}
10528			b := dAtA[iNdEx]
10529			iNdEx++
10530			wire |= (uint64(b) & 0x7F) << shift
10531			if b < 0x80 {
10532				break
10533			}
10534		}
10535		fieldNum := int32(wire >> 3)
10536		wireType := int(wire & 0x7)
10537		if wireType == 4 {
10538			return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
10539		}
10540		if fieldNum <= 0 {
10541			return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
10542		}
10543		switch fieldNum {
10544		case 1:
10545			if wireType != 2 {
10546				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
10547			}
10548			var msglen int
10549			for shift := uint(0); ; shift += 7 {
10550				if shift >= 64 {
10551					return ErrIntOverflowGenerated
10552				}
10553				if iNdEx >= l {
10554					return io.ErrUnexpectedEOF
10555				}
10556				b := dAtA[iNdEx]
10557				iNdEx++
10558				msglen |= (int(b) & 0x7F) << shift
10559				if b < 0x80 {
10560					break
10561				}
10562			}
10563			if msglen < 0 {
10564				return ErrInvalidLengthGenerated
10565			}
10566			postIndex := iNdEx + msglen
10567			if postIndex > l {
10568				return io.ErrUnexpectedEOF
10569			}
10570			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10571				return err
10572			}
10573			iNdEx = postIndex
10574		case 2:
10575			if wireType != 2 {
10576				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
10577			}
10578			var msglen int
10579			for shift := uint(0); ; shift += 7 {
10580				if shift >= 64 {
10581					return ErrIntOverflowGenerated
10582				}
10583				if iNdEx >= l {
10584					return io.ErrUnexpectedEOF
10585				}
10586				b := dAtA[iNdEx]
10587				iNdEx++
10588				msglen |= (int(b) & 0x7F) << shift
10589				if b < 0x80 {
10590					break
10591				}
10592			}
10593			if msglen < 0 {
10594				return ErrInvalidLengthGenerated
10595			}
10596			postIndex := iNdEx + msglen
10597			if postIndex > l {
10598				return io.ErrUnexpectedEOF
10599			}
10600			m.Items = append(m.Items, ReplicaSet{})
10601			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10602				return err
10603			}
10604			iNdEx = postIndex
10605		default:
10606			iNdEx = preIndex
10607			skippy, err := skipGenerated(dAtA[iNdEx:])
10608			if err != nil {
10609				return err
10610			}
10611			if skippy < 0 {
10612				return ErrInvalidLengthGenerated
10613			}
10614			if (iNdEx + skippy) > l {
10615				return io.ErrUnexpectedEOF
10616			}
10617			iNdEx += skippy
10618		}
10619	}
10620
10621	if iNdEx > l {
10622		return io.ErrUnexpectedEOF
10623	}
10624	return nil
10625}
10626func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
10627	l := len(dAtA)
10628	iNdEx := 0
10629	for iNdEx < l {
10630		preIndex := iNdEx
10631		var wire uint64
10632		for shift := uint(0); ; shift += 7 {
10633			if shift >= 64 {
10634				return ErrIntOverflowGenerated
10635			}
10636			if iNdEx >= l {
10637				return io.ErrUnexpectedEOF
10638			}
10639			b := dAtA[iNdEx]
10640			iNdEx++
10641			wire |= (uint64(b) & 0x7F) << shift
10642			if b < 0x80 {
10643				break
10644			}
10645		}
10646		fieldNum := int32(wire >> 3)
10647		wireType := int(wire & 0x7)
10648		if wireType == 4 {
10649			return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
10650		}
10651		if fieldNum <= 0 {
10652			return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
10653		}
10654		switch fieldNum {
10655		case 1:
10656			if wireType != 0 {
10657				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10658			}
10659			var v int32
10660			for shift := uint(0); ; shift += 7 {
10661				if shift >= 64 {
10662					return ErrIntOverflowGenerated
10663				}
10664				if iNdEx >= l {
10665					return io.ErrUnexpectedEOF
10666				}
10667				b := dAtA[iNdEx]
10668				iNdEx++
10669				v |= (int32(b) & 0x7F) << shift
10670				if b < 0x80 {
10671					break
10672				}
10673			}
10674			m.Replicas = &v
10675		case 2:
10676			if wireType != 2 {
10677				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
10678			}
10679			var msglen int
10680			for shift := uint(0); ; shift += 7 {
10681				if shift >= 64 {
10682					return ErrIntOverflowGenerated
10683				}
10684				if iNdEx >= l {
10685					return io.ErrUnexpectedEOF
10686				}
10687				b := dAtA[iNdEx]
10688				iNdEx++
10689				msglen |= (int(b) & 0x7F) << shift
10690				if b < 0x80 {
10691					break
10692				}
10693			}
10694			if msglen < 0 {
10695				return ErrInvalidLengthGenerated
10696			}
10697			postIndex := iNdEx + msglen
10698			if postIndex > l {
10699				return io.ErrUnexpectedEOF
10700			}
10701			if m.Selector == nil {
10702				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
10703			}
10704			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10705				return err
10706			}
10707			iNdEx = postIndex
10708		case 3:
10709			if wireType != 2 {
10710				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
10711			}
10712			var msglen int
10713			for shift := uint(0); ; shift += 7 {
10714				if shift >= 64 {
10715					return ErrIntOverflowGenerated
10716				}
10717				if iNdEx >= l {
10718					return io.ErrUnexpectedEOF
10719				}
10720				b := dAtA[iNdEx]
10721				iNdEx++
10722				msglen |= (int(b) & 0x7F) << shift
10723				if b < 0x80 {
10724					break
10725				}
10726			}
10727			if msglen < 0 {
10728				return ErrInvalidLengthGenerated
10729			}
10730			postIndex := iNdEx + msglen
10731			if postIndex > l {
10732				return io.ErrUnexpectedEOF
10733			}
10734			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10735				return err
10736			}
10737			iNdEx = postIndex
10738		case 4:
10739			if wireType != 0 {
10740				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
10741			}
10742			m.MinReadySeconds = 0
10743			for shift := uint(0); ; shift += 7 {
10744				if shift >= 64 {
10745					return ErrIntOverflowGenerated
10746				}
10747				if iNdEx >= l {
10748					return io.ErrUnexpectedEOF
10749				}
10750				b := dAtA[iNdEx]
10751				iNdEx++
10752				m.MinReadySeconds |= (int32(b) & 0x7F) << shift
10753				if b < 0x80 {
10754					break
10755				}
10756			}
10757		default:
10758			iNdEx = preIndex
10759			skippy, err := skipGenerated(dAtA[iNdEx:])
10760			if err != nil {
10761				return err
10762			}
10763			if skippy < 0 {
10764				return ErrInvalidLengthGenerated
10765			}
10766			if (iNdEx + skippy) > l {
10767				return io.ErrUnexpectedEOF
10768			}
10769			iNdEx += skippy
10770		}
10771	}
10772
10773	if iNdEx > l {
10774		return io.ErrUnexpectedEOF
10775	}
10776	return nil
10777}
10778func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
10779	l := len(dAtA)
10780	iNdEx := 0
10781	for iNdEx < l {
10782		preIndex := iNdEx
10783		var wire uint64
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			wire |= (uint64(b) & 0x7F) << shift
10794			if b < 0x80 {
10795				break
10796			}
10797		}
10798		fieldNum := int32(wire >> 3)
10799		wireType := int(wire & 0x7)
10800		if wireType == 4 {
10801			return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
10802		}
10803		if fieldNum <= 0 {
10804			return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
10805		}
10806		switch fieldNum {
10807		case 1:
10808			if wireType != 0 {
10809				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
10810			}
10811			m.Replicas = 0
10812			for shift := uint(0); ; shift += 7 {
10813				if shift >= 64 {
10814					return ErrIntOverflowGenerated
10815				}
10816				if iNdEx >= l {
10817					return io.ErrUnexpectedEOF
10818				}
10819				b := dAtA[iNdEx]
10820				iNdEx++
10821				m.Replicas |= (int32(b) & 0x7F) << shift
10822				if b < 0x80 {
10823					break
10824				}
10825			}
10826		case 2:
10827			if wireType != 0 {
10828				return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
10829			}
10830			m.FullyLabeledReplicas = 0
10831			for shift := uint(0); ; shift += 7 {
10832				if shift >= 64 {
10833					return ErrIntOverflowGenerated
10834				}
10835				if iNdEx >= l {
10836					return io.ErrUnexpectedEOF
10837				}
10838				b := dAtA[iNdEx]
10839				iNdEx++
10840				m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
10841				if b < 0x80 {
10842					break
10843				}
10844			}
10845		case 3:
10846			if wireType != 0 {
10847				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
10848			}
10849			m.ObservedGeneration = 0
10850			for shift := uint(0); ; shift += 7 {
10851				if shift >= 64 {
10852					return ErrIntOverflowGenerated
10853				}
10854				if iNdEx >= l {
10855					return io.ErrUnexpectedEOF
10856				}
10857				b := dAtA[iNdEx]
10858				iNdEx++
10859				m.ObservedGeneration |= (int64(b) & 0x7F) << shift
10860				if b < 0x80 {
10861					break
10862				}
10863			}
10864		case 4:
10865			if wireType != 0 {
10866				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
10867			}
10868			m.ReadyReplicas = 0
10869			for shift := uint(0); ; shift += 7 {
10870				if shift >= 64 {
10871					return ErrIntOverflowGenerated
10872				}
10873				if iNdEx >= l {
10874					return io.ErrUnexpectedEOF
10875				}
10876				b := dAtA[iNdEx]
10877				iNdEx++
10878				m.ReadyReplicas |= (int32(b) & 0x7F) << shift
10879				if b < 0x80 {
10880					break
10881				}
10882			}
10883		case 5:
10884			if wireType != 0 {
10885				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
10886			}
10887			m.AvailableReplicas = 0
10888			for shift := uint(0); ; shift += 7 {
10889				if shift >= 64 {
10890					return ErrIntOverflowGenerated
10891				}
10892				if iNdEx >= l {
10893					return io.ErrUnexpectedEOF
10894				}
10895				b := dAtA[iNdEx]
10896				iNdEx++
10897				m.AvailableReplicas |= (int32(b) & 0x7F) << shift
10898				if b < 0x80 {
10899					break
10900				}
10901			}
10902		case 6:
10903			if wireType != 2 {
10904				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
10905			}
10906			var msglen int
10907			for shift := uint(0); ; shift += 7 {
10908				if shift >= 64 {
10909					return ErrIntOverflowGenerated
10910				}
10911				if iNdEx >= l {
10912					return io.ErrUnexpectedEOF
10913				}
10914				b := dAtA[iNdEx]
10915				iNdEx++
10916				msglen |= (int(b) & 0x7F) << shift
10917				if b < 0x80 {
10918					break
10919				}
10920			}
10921			if msglen < 0 {
10922				return ErrInvalidLengthGenerated
10923			}
10924			postIndex := iNdEx + msglen
10925			if postIndex > l {
10926				return io.ErrUnexpectedEOF
10927			}
10928			m.Conditions = append(m.Conditions, ReplicaSetCondition{})
10929			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
10930				return err
10931			}
10932			iNdEx = postIndex
10933		default:
10934			iNdEx = preIndex
10935			skippy, err := skipGenerated(dAtA[iNdEx:])
10936			if err != nil {
10937				return err
10938			}
10939			if skippy < 0 {
10940				return ErrInvalidLengthGenerated
10941			}
10942			if (iNdEx + skippy) > l {
10943				return io.ErrUnexpectedEOF
10944			}
10945			iNdEx += skippy
10946		}
10947	}
10948
10949	if iNdEx > l {
10950		return io.ErrUnexpectedEOF
10951	}
10952	return nil
10953}
10954func (m *ReplicationControllerDummy) Unmarshal(dAtA []byte) error {
10955	l := len(dAtA)
10956	iNdEx := 0
10957	for iNdEx < l {
10958		preIndex := iNdEx
10959		var wire uint64
10960		for shift := uint(0); ; shift += 7 {
10961			if shift >= 64 {
10962				return ErrIntOverflowGenerated
10963			}
10964			if iNdEx >= l {
10965				return io.ErrUnexpectedEOF
10966			}
10967			b := dAtA[iNdEx]
10968			iNdEx++
10969			wire |= (uint64(b) & 0x7F) << shift
10970			if b < 0x80 {
10971				break
10972			}
10973		}
10974		fieldNum := int32(wire >> 3)
10975		wireType := int(wire & 0x7)
10976		if wireType == 4 {
10977			return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group")
10978		}
10979		if fieldNum <= 0 {
10980			return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire)
10981		}
10982		switch fieldNum {
10983		default:
10984			iNdEx = preIndex
10985			skippy, err := skipGenerated(dAtA[iNdEx:])
10986			if err != nil {
10987				return err
10988			}
10989			if skippy < 0 {
10990				return ErrInvalidLengthGenerated
10991			}
10992			if (iNdEx + skippy) > l {
10993				return io.ErrUnexpectedEOF
10994			}
10995			iNdEx += skippy
10996		}
10997	}
10998
10999	if iNdEx > l {
11000		return io.ErrUnexpectedEOF
11001	}
11002	return nil
11003}
11004func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
11005	l := len(dAtA)
11006	iNdEx := 0
11007	for iNdEx < l {
11008		preIndex := iNdEx
11009		var wire uint64
11010		for shift := uint(0); ; shift += 7 {
11011			if shift >= 64 {
11012				return ErrIntOverflowGenerated
11013			}
11014			if iNdEx >= l {
11015				return io.ErrUnexpectedEOF
11016			}
11017			b := dAtA[iNdEx]
11018			iNdEx++
11019			wire |= (uint64(b) & 0x7F) << shift
11020			if b < 0x80 {
11021				break
11022			}
11023		}
11024		fieldNum := int32(wire >> 3)
11025		wireType := int(wire & 0x7)
11026		if wireType == 4 {
11027			return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
11028		}
11029		if fieldNum <= 0 {
11030			return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
11031		}
11032		switch fieldNum {
11033		case 1:
11034			if wireType != 0 {
11035				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
11036			}
11037			m.Revision = 0
11038			for shift := uint(0); ; shift += 7 {
11039				if shift >= 64 {
11040					return ErrIntOverflowGenerated
11041				}
11042				if iNdEx >= l {
11043					return io.ErrUnexpectedEOF
11044				}
11045				b := dAtA[iNdEx]
11046				iNdEx++
11047				m.Revision |= (int64(b) & 0x7F) << shift
11048				if b < 0x80 {
11049					break
11050				}
11051			}
11052		default:
11053			iNdEx = preIndex
11054			skippy, err := skipGenerated(dAtA[iNdEx:])
11055			if err != nil {
11056				return err
11057			}
11058			if skippy < 0 {
11059				return ErrInvalidLengthGenerated
11060			}
11061			if (iNdEx + skippy) > l {
11062				return io.ErrUnexpectedEOF
11063			}
11064			iNdEx += skippy
11065		}
11066	}
11067
11068	if iNdEx > l {
11069		return io.ErrUnexpectedEOF
11070	}
11071	return nil
11072}
11073func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
11074	l := len(dAtA)
11075	iNdEx := 0
11076	for iNdEx < l {
11077		preIndex := iNdEx
11078		var wire uint64
11079		for shift := uint(0); ; shift += 7 {
11080			if shift >= 64 {
11081				return ErrIntOverflowGenerated
11082			}
11083			if iNdEx >= l {
11084				return io.ErrUnexpectedEOF
11085			}
11086			b := dAtA[iNdEx]
11087			iNdEx++
11088			wire |= (uint64(b) & 0x7F) << shift
11089			if b < 0x80 {
11090				break
11091			}
11092		}
11093		fieldNum := int32(wire >> 3)
11094		wireType := int(wire & 0x7)
11095		if wireType == 4 {
11096			return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
11097		}
11098		if fieldNum <= 0 {
11099			return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
11100		}
11101		switch fieldNum {
11102		case 1:
11103			if wireType != 2 {
11104				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
11105			}
11106			var msglen int
11107			for shift := uint(0); ; shift += 7 {
11108				if shift >= 64 {
11109					return ErrIntOverflowGenerated
11110				}
11111				if iNdEx >= l {
11112					return io.ErrUnexpectedEOF
11113				}
11114				b := dAtA[iNdEx]
11115				iNdEx++
11116				msglen |= (int(b) & 0x7F) << shift
11117				if b < 0x80 {
11118					break
11119				}
11120			}
11121			if msglen < 0 {
11122				return ErrInvalidLengthGenerated
11123			}
11124			postIndex := iNdEx + msglen
11125			if postIndex > l {
11126				return io.ErrUnexpectedEOF
11127			}
11128			if m.MaxUnavailable == nil {
11129				m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11130			}
11131			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11132				return err
11133			}
11134			iNdEx = postIndex
11135		default:
11136			iNdEx = preIndex
11137			skippy, err := skipGenerated(dAtA[iNdEx:])
11138			if err != nil {
11139				return err
11140			}
11141			if skippy < 0 {
11142				return ErrInvalidLengthGenerated
11143			}
11144			if (iNdEx + skippy) > l {
11145				return io.ErrUnexpectedEOF
11146			}
11147			iNdEx += skippy
11148		}
11149	}
11150
11151	if iNdEx > l {
11152		return io.ErrUnexpectedEOF
11153	}
11154	return nil
11155}
11156func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
11157	l := len(dAtA)
11158	iNdEx := 0
11159	for iNdEx < l {
11160		preIndex := iNdEx
11161		var wire uint64
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			wire |= (uint64(b) & 0x7F) << shift
11172			if b < 0x80 {
11173				break
11174			}
11175		}
11176		fieldNum := int32(wire >> 3)
11177		wireType := int(wire & 0x7)
11178		if wireType == 4 {
11179			return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
11180		}
11181		if fieldNum <= 0 {
11182			return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
11183		}
11184		switch fieldNum {
11185		case 1:
11186			if wireType != 2 {
11187				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
11188			}
11189			var msglen int
11190			for shift := uint(0); ; shift += 7 {
11191				if shift >= 64 {
11192					return ErrIntOverflowGenerated
11193				}
11194				if iNdEx >= l {
11195					return io.ErrUnexpectedEOF
11196				}
11197				b := dAtA[iNdEx]
11198				iNdEx++
11199				msglen |= (int(b) & 0x7F) << shift
11200				if b < 0x80 {
11201					break
11202				}
11203			}
11204			if msglen < 0 {
11205				return ErrInvalidLengthGenerated
11206			}
11207			postIndex := iNdEx + msglen
11208			if postIndex > l {
11209				return io.ErrUnexpectedEOF
11210			}
11211			if m.MaxUnavailable == nil {
11212				m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11213			}
11214			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11215				return err
11216			}
11217			iNdEx = postIndex
11218		case 2:
11219			if wireType != 2 {
11220				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
11221			}
11222			var msglen int
11223			for shift := uint(0); ; shift += 7 {
11224				if shift >= 64 {
11225					return ErrIntOverflowGenerated
11226				}
11227				if iNdEx >= l {
11228					return io.ErrUnexpectedEOF
11229				}
11230				b := dAtA[iNdEx]
11231				iNdEx++
11232				msglen |= (int(b) & 0x7F) << shift
11233				if b < 0x80 {
11234					break
11235				}
11236			}
11237			if msglen < 0 {
11238				return ErrInvalidLengthGenerated
11239			}
11240			postIndex := iNdEx + msglen
11241			if postIndex > l {
11242				return io.ErrUnexpectedEOF
11243			}
11244			if m.MaxSurge == nil {
11245				m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
11246			}
11247			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11248				return err
11249			}
11250			iNdEx = postIndex
11251		default:
11252			iNdEx = preIndex
11253			skippy, err := skipGenerated(dAtA[iNdEx:])
11254			if err != nil {
11255				return err
11256			}
11257			if skippy < 0 {
11258				return ErrInvalidLengthGenerated
11259			}
11260			if (iNdEx + skippy) > l {
11261				return io.ErrUnexpectedEOF
11262			}
11263			iNdEx += skippy
11264		}
11265	}
11266
11267	if iNdEx > l {
11268		return io.ErrUnexpectedEOF
11269	}
11270	return nil
11271}
11272func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error {
11273	l := len(dAtA)
11274	iNdEx := 0
11275	for iNdEx < l {
11276		preIndex := iNdEx
11277		var wire uint64
11278		for shift := uint(0); ; shift += 7 {
11279			if shift >= 64 {
11280				return ErrIntOverflowGenerated
11281			}
11282			if iNdEx >= l {
11283				return io.ErrUnexpectedEOF
11284			}
11285			b := dAtA[iNdEx]
11286			iNdEx++
11287			wire |= (uint64(b) & 0x7F) << shift
11288			if b < 0x80 {
11289				break
11290			}
11291		}
11292		fieldNum := int32(wire >> 3)
11293		wireType := int(wire & 0x7)
11294		if wireType == 4 {
11295			return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group")
11296		}
11297		if fieldNum <= 0 {
11298			return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11299		}
11300		switch fieldNum {
11301		case 1:
11302			if wireType != 2 {
11303				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11304			}
11305			var stringLen uint64
11306			for shift := uint(0); ; shift += 7 {
11307				if shift >= 64 {
11308					return ErrIntOverflowGenerated
11309				}
11310				if iNdEx >= l {
11311					return io.ErrUnexpectedEOF
11312				}
11313				b := dAtA[iNdEx]
11314				iNdEx++
11315				stringLen |= (uint64(b) & 0x7F) << shift
11316				if b < 0x80 {
11317					break
11318				}
11319			}
11320			intStringLen := int(stringLen)
11321			if intStringLen < 0 {
11322				return ErrInvalidLengthGenerated
11323			}
11324			postIndex := iNdEx + intStringLen
11325			if postIndex > l {
11326				return io.ErrUnexpectedEOF
11327			}
11328			m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex])
11329			iNdEx = postIndex
11330		case 2:
11331			if wireType != 2 {
11332				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11333			}
11334			var msglen int
11335			for shift := uint(0); ; shift += 7 {
11336				if shift >= 64 {
11337					return ErrIntOverflowGenerated
11338				}
11339				if iNdEx >= l {
11340					return io.ErrUnexpectedEOF
11341				}
11342				b := dAtA[iNdEx]
11343				iNdEx++
11344				msglen |= (int(b) & 0x7F) << shift
11345				if b < 0x80 {
11346					break
11347				}
11348			}
11349			if msglen < 0 {
11350				return ErrInvalidLengthGenerated
11351			}
11352			postIndex := iNdEx + msglen
11353			if postIndex > l {
11354				return io.ErrUnexpectedEOF
11355			}
11356			m.Ranges = append(m.Ranges, IDRange{})
11357			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11358				return err
11359			}
11360			iNdEx = postIndex
11361		default:
11362			iNdEx = preIndex
11363			skippy, err := skipGenerated(dAtA[iNdEx:])
11364			if err != nil {
11365				return err
11366			}
11367			if skippy < 0 {
11368				return ErrInvalidLengthGenerated
11369			}
11370			if (iNdEx + skippy) > l {
11371				return io.ErrUnexpectedEOF
11372			}
11373			iNdEx += skippy
11374		}
11375	}
11376
11377	if iNdEx > l {
11378		return io.ErrUnexpectedEOF
11379	}
11380	return nil
11381}
11382func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error {
11383	l := len(dAtA)
11384	iNdEx := 0
11385	for iNdEx < l {
11386		preIndex := iNdEx
11387		var wire uint64
11388		for shift := uint(0); ; shift += 7 {
11389			if shift >= 64 {
11390				return ErrIntOverflowGenerated
11391			}
11392			if iNdEx >= l {
11393				return io.ErrUnexpectedEOF
11394			}
11395			b := dAtA[iNdEx]
11396			iNdEx++
11397			wire |= (uint64(b) & 0x7F) << shift
11398			if b < 0x80 {
11399				break
11400			}
11401		}
11402		fieldNum := int32(wire >> 3)
11403		wireType := int(wire & 0x7)
11404		if wireType == 4 {
11405			return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group")
11406		}
11407		if fieldNum <= 0 {
11408			return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11409		}
11410		switch fieldNum {
11411		case 1:
11412			if wireType != 2 {
11413				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11414			}
11415			var stringLen uint64
11416			for shift := uint(0); ; shift += 7 {
11417				if shift >= 64 {
11418					return ErrIntOverflowGenerated
11419				}
11420				if iNdEx >= l {
11421					return io.ErrUnexpectedEOF
11422				}
11423				b := dAtA[iNdEx]
11424				iNdEx++
11425				stringLen |= (uint64(b) & 0x7F) << shift
11426				if b < 0x80 {
11427					break
11428				}
11429			}
11430			intStringLen := int(stringLen)
11431			if intStringLen < 0 {
11432				return ErrInvalidLengthGenerated
11433			}
11434			postIndex := iNdEx + intStringLen
11435			if postIndex > l {
11436				return io.ErrUnexpectedEOF
11437			}
11438			m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex])
11439			iNdEx = postIndex
11440		case 2:
11441			if wireType != 2 {
11442				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
11443			}
11444			var msglen int
11445			for shift := uint(0); ; shift += 7 {
11446				if shift >= 64 {
11447					return ErrIntOverflowGenerated
11448				}
11449				if iNdEx >= l {
11450					return io.ErrUnexpectedEOF
11451				}
11452				b := dAtA[iNdEx]
11453				iNdEx++
11454				msglen |= (int(b) & 0x7F) << shift
11455				if b < 0x80 {
11456					break
11457				}
11458			}
11459			if msglen < 0 {
11460				return ErrInvalidLengthGenerated
11461			}
11462			postIndex := iNdEx + msglen
11463			if postIndex > l {
11464				return io.ErrUnexpectedEOF
11465			}
11466			m.Ranges = append(m.Ranges, IDRange{})
11467			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11468				return err
11469			}
11470			iNdEx = postIndex
11471		default:
11472			iNdEx = preIndex
11473			skippy, err := skipGenerated(dAtA[iNdEx:])
11474			if err != nil {
11475				return err
11476			}
11477			if skippy < 0 {
11478				return ErrInvalidLengthGenerated
11479			}
11480			if (iNdEx + skippy) > l {
11481				return io.ErrUnexpectedEOF
11482			}
11483			iNdEx += skippy
11484		}
11485	}
11486
11487	if iNdEx > l {
11488		return io.ErrUnexpectedEOF
11489	}
11490	return nil
11491}
11492func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error {
11493	l := len(dAtA)
11494	iNdEx := 0
11495	for iNdEx < l {
11496		preIndex := iNdEx
11497		var wire uint64
11498		for shift := uint(0); ; shift += 7 {
11499			if shift >= 64 {
11500				return ErrIntOverflowGenerated
11501			}
11502			if iNdEx >= l {
11503				return io.ErrUnexpectedEOF
11504			}
11505			b := dAtA[iNdEx]
11506			iNdEx++
11507			wire |= (uint64(b) & 0x7F) << shift
11508			if b < 0x80 {
11509				break
11510			}
11511		}
11512		fieldNum := int32(wire >> 3)
11513		wireType := int(wire & 0x7)
11514		if wireType == 4 {
11515			return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group")
11516		}
11517		if fieldNum <= 0 {
11518			return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
11519		}
11520		switch fieldNum {
11521		case 1:
11522			if wireType != 2 {
11523				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
11524			}
11525			var stringLen uint64
11526			for shift := uint(0); ; shift += 7 {
11527				if shift >= 64 {
11528					return ErrIntOverflowGenerated
11529				}
11530				if iNdEx >= l {
11531					return io.ErrUnexpectedEOF
11532				}
11533				b := dAtA[iNdEx]
11534				iNdEx++
11535				stringLen |= (uint64(b) & 0x7F) << shift
11536				if b < 0x80 {
11537					break
11538				}
11539			}
11540			intStringLen := int(stringLen)
11541			if intStringLen < 0 {
11542				return ErrInvalidLengthGenerated
11543			}
11544			postIndex := iNdEx + intStringLen
11545			if postIndex > l {
11546				return io.ErrUnexpectedEOF
11547			}
11548			m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex])
11549			iNdEx = postIndex
11550		case 2:
11551			if wireType != 2 {
11552				return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType)
11553			}
11554			var msglen int
11555			for shift := uint(0); ; shift += 7 {
11556				if shift >= 64 {
11557					return ErrIntOverflowGenerated
11558				}
11559				if iNdEx >= l {
11560					return io.ErrUnexpectedEOF
11561				}
11562				b := dAtA[iNdEx]
11563				iNdEx++
11564				msglen |= (int(b) & 0x7F) << shift
11565				if b < 0x80 {
11566					break
11567				}
11568			}
11569			if msglen < 0 {
11570				return ErrInvalidLengthGenerated
11571			}
11572			postIndex := iNdEx + msglen
11573			if postIndex > l {
11574				return io.ErrUnexpectedEOF
11575			}
11576			if m.SELinuxOptions == nil {
11577				m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{}
11578			}
11579			if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11580				return err
11581			}
11582			iNdEx = postIndex
11583		default:
11584			iNdEx = preIndex
11585			skippy, err := skipGenerated(dAtA[iNdEx:])
11586			if err != nil {
11587				return err
11588			}
11589			if skippy < 0 {
11590				return ErrInvalidLengthGenerated
11591			}
11592			if (iNdEx + skippy) > l {
11593				return io.ErrUnexpectedEOF
11594			}
11595			iNdEx += skippy
11596		}
11597	}
11598
11599	if iNdEx > l {
11600		return io.ErrUnexpectedEOF
11601	}
11602	return nil
11603}
11604func (m *Scale) Unmarshal(dAtA []byte) error {
11605	l := len(dAtA)
11606	iNdEx := 0
11607	for iNdEx < l {
11608		preIndex := iNdEx
11609		var wire uint64
11610		for shift := uint(0); ; shift += 7 {
11611			if shift >= 64 {
11612				return ErrIntOverflowGenerated
11613			}
11614			if iNdEx >= l {
11615				return io.ErrUnexpectedEOF
11616			}
11617			b := dAtA[iNdEx]
11618			iNdEx++
11619			wire |= (uint64(b) & 0x7F) << shift
11620			if b < 0x80 {
11621				break
11622			}
11623		}
11624		fieldNum := int32(wire >> 3)
11625		wireType := int(wire & 0x7)
11626		if wireType == 4 {
11627			return fmt.Errorf("proto: Scale: wiretype end group for non-group")
11628		}
11629		if fieldNum <= 0 {
11630			return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
11631		}
11632		switch fieldNum {
11633		case 1:
11634			if wireType != 2 {
11635				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
11636			}
11637			var msglen int
11638			for shift := uint(0); ; shift += 7 {
11639				if shift >= 64 {
11640					return ErrIntOverflowGenerated
11641				}
11642				if iNdEx >= l {
11643					return io.ErrUnexpectedEOF
11644				}
11645				b := dAtA[iNdEx]
11646				iNdEx++
11647				msglen |= (int(b) & 0x7F) << shift
11648				if b < 0x80 {
11649					break
11650				}
11651			}
11652			if msglen < 0 {
11653				return ErrInvalidLengthGenerated
11654			}
11655			postIndex := iNdEx + msglen
11656			if postIndex > l {
11657				return io.ErrUnexpectedEOF
11658			}
11659			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11660				return err
11661			}
11662			iNdEx = postIndex
11663		case 2:
11664			if wireType != 2 {
11665				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
11666			}
11667			var msglen int
11668			for shift := uint(0); ; shift += 7 {
11669				if shift >= 64 {
11670					return ErrIntOverflowGenerated
11671				}
11672				if iNdEx >= l {
11673					return io.ErrUnexpectedEOF
11674				}
11675				b := dAtA[iNdEx]
11676				iNdEx++
11677				msglen |= (int(b) & 0x7F) << shift
11678				if b < 0x80 {
11679					break
11680				}
11681			}
11682			if msglen < 0 {
11683				return ErrInvalidLengthGenerated
11684			}
11685			postIndex := iNdEx + msglen
11686			if postIndex > l {
11687				return io.ErrUnexpectedEOF
11688			}
11689			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11690				return err
11691			}
11692			iNdEx = postIndex
11693		case 3:
11694			if wireType != 2 {
11695				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
11696			}
11697			var msglen int
11698			for shift := uint(0); ; shift += 7 {
11699				if shift >= 64 {
11700					return ErrIntOverflowGenerated
11701				}
11702				if iNdEx >= l {
11703					return io.ErrUnexpectedEOF
11704				}
11705				b := dAtA[iNdEx]
11706				iNdEx++
11707				msglen |= (int(b) & 0x7F) << shift
11708				if b < 0x80 {
11709					break
11710				}
11711			}
11712			if msglen < 0 {
11713				return ErrInvalidLengthGenerated
11714			}
11715			postIndex := iNdEx + msglen
11716			if postIndex > l {
11717				return io.ErrUnexpectedEOF
11718			}
11719			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
11720				return err
11721			}
11722			iNdEx = postIndex
11723		default:
11724			iNdEx = preIndex
11725			skippy, err := skipGenerated(dAtA[iNdEx:])
11726			if err != nil {
11727				return err
11728			}
11729			if skippy < 0 {
11730				return ErrInvalidLengthGenerated
11731			}
11732			if (iNdEx + skippy) > l {
11733				return io.ErrUnexpectedEOF
11734			}
11735			iNdEx += skippy
11736		}
11737	}
11738
11739	if iNdEx > l {
11740		return io.ErrUnexpectedEOF
11741	}
11742	return nil
11743}
11744func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
11745	l := len(dAtA)
11746	iNdEx := 0
11747	for iNdEx < l {
11748		preIndex := iNdEx
11749		var wire uint64
11750		for shift := uint(0); ; shift += 7 {
11751			if shift >= 64 {
11752				return ErrIntOverflowGenerated
11753			}
11754			if iNdEx >= l {
11755				return io.ErrUnexpectedEOF
11756			}
11757			b := dAtA[iNdEx]
11758			iNdEx++
11759			wire |= (uint64(b) & 0x7F) << shift
11760			if b < 0x80 {
11761				break
11762			}
11763		}
11764		fieldNum := int32(wire >> 3)
11765		wireType := int(wire & 0x7)
11766		if wireType == 4 {
11767			return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
11768		}
11769		if fieldNum <= 0 {
11770			return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
11771		}
11772		switch fieldNum {
11773		case 1:
11774			if wireType != 0 {
11775				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
11776			}
11777			m.Replicas = 0
11778			for shift := uint(0); ; shift += 7 {
11779				if shift >= 64 {
11780					return ErrIntOverflowGenerated
11781				}
11782				if iNdEx >= l {
11783					return io.ErrUnexpectedEOF
11784				}
11785				b := dAtA[iNdEx]
11786				iNdEx++
11787				m.Replicas |= (int32(b) & 0x7F) << shift
11788				if b < 0x80 {
11789					break
11790				}
11791			}
11792		default:
11793			iNdEx = preIndex
11794			skippy, err := skipGenerated(dAtA[iNdEx:])
11795			if err != nil {
11796				return err
11797			}
11798			if skippy < 0 {
11799				return ErrInvalidLengthGenerated
11800			}
11801			if (iNdEx + skippy) > l {
11802				return io.ErrUnexpectedEOF
11803			}
11804			iNdEx += skippy
11805		}
11806	}
11807
11808	if iNdEx > l {
11809		return io.ErrUnexpectedEOF
11810	}
11811	return nil
11812}
11813func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
11814	l := len(dAtA)
11815	iNdEx := 0
11816	for iNdEx < l {
11817		preIndex := iNdEx
11818		var wire uint64
11819		for shift := uint(0); ; shift += 7 {
11820			if shift >= 64 {
11821				return ErrIntOverflowGenerated
11822			}
11823			if iNdEx >= l {
11824				return io.ErrUnexpectedEOF
11825			}
11826			b := dAtA[iNdEx]
11827			iNdEx++
11828			wire |= (uint64(b) & 0x7F) << shift
11829			if b < 0x80 {
11830				break
11831			}
11832		}
11833		fieldNum := int32(wire >> 3)
11834		wireType := int(wire & 0x7)
11835		if wireType == 4 {
11836			return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
11837		}
11838		if fieldNum <= 0 {
11839			return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
11840		}
11841		switch fieldNum {
11842		case 1:
11843			if wireType != 0 {
11844				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
11845			}
11846			m.Replicas = 0
11847			for shift := uint(0); ; shift += 7 {
11848				if shift >= 64 {
11849					return ErrIntOverflowGenerated
11850				}
11851				if iNdEx >= l {
11852					return io.ErrUnexpectedEOF
11853				}
11854				b := dAtA[iNdEx]
11855				iNdEx++
11856				m.Replicas |= (int32(b) & 0x7F) << shift
11857				if b < 0x80 {
11858					break
11859				}
11860			}
11861		case 2:
11862			if wireType != 2 {
11863				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
11864			}
11865			var msglen int
11866			for shift := uint(0); ; shift += 7 {
11867				if shift >= 64 {
11868					return ErrIntOverflowGenerated
11869				}
11870				if iNdEx >= l {
11871					return io.ErrUnexpectedEOF
11872				}
11873				b := dAtA[iNdEx]
11874				iNdEx++
11875				msglen |= (int(b) & 0x7F) << shift
11876				if b < 0x80 {
11877					break
11878				}
11879			}
11880			if msglen < 0 {
11881				return ErrInvalidLengthGenerated
11882			}
11883			postIndex := iNdEx + msglen
11884			if postIndex > l {
11885				return io.ErrUnexpectedEOF
11886			}
11887			if m.Selector == nil {
11888				m.Selector = make(map[string]string)
11889			}
11890			var mapkey string
11891			var mapvalue string
11892			for iNdEx < postIndex {
11893				entryPreIndex := iNdEx
11894				var wire uint64
11895				for shift := uint(0); ; shift += 7 {
11896					if shift >= 64 {
11897						return ErrIntOverflowGenerated
11898					}
11899					if iNdEx >= l {
11900						return io.ErrUnexpectedEOF
11901					}
11902					b := dAtA[iNdEx]
11903					iNdEx++
11904					wire |= (uint64(b) & 0x7F) << shift
11905					if b < 0x80 {
11906						break
11907					}
11908				}
11909				fieldNum := int32(wire >> 3)
11910				if fieldNum == 1 {
11911					var stringLenmapkey uint64
11912					for shift := uint(0); ; shift += 7 {
11913						if shift >= 64 {
11914							return ErrIntOverflowGenerated
11915						}
11916						if iNdEx >= l {
11917							return io.ErrUnexpectedEOF
11918						}
11919						b := dAtA[iNdEx]
11920						iNdEx++
11921						stringLenmapkey |= (uint64(b) & 0x7F) << shift
11922						if b < 0x80 {
11923							break
11924						}
11925					}
11926					intStringLenmapkey := int(stringLenmapkey)
11927					if intStringLenmapkey < 0 {
11928						return ErrInvalidLengthGenerated
11929					}
11930					postStringIndexmapkey := iNdEx + intStringLenmapkey
11931					if postStringIndexmapkey > l {
11932						return io.ErrUnexpectedEOF
11933					}
11934					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
11935					iNdEx = postStringIndexmapkey
11936				} else if fieldNum == 2 {
11937					var stringLenmapvalue uint64
11938					for shift := uint(0); ; shift += 7 {
11939						if shift >= 64 {
11940							return ErrIntOverflowGenerated
11941						}
11942						if iNdEx >= l {
11943							return io.ErrUnexpectedEOF
11944						}
11945						b := dAtA[iNdEx]
11946						iNdEx++
11947						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
11948						if b < 0x80 {
11949							break
11950						}
11951					}
11952					intStringLenmapvalue := int(stringLenmapvalue)
11953					if intStringLenmapvalue < 0 {
11954						return ErrInvalidLengthGenerated
11955					}
11956					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
11957					if postStringIndexmapvalue > l {
11958						return io.ErrUnexpectedEOF
11959					}
11960					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
11961					iNdEx = postStringIndexmapvalue
11962				} else {
11963					iNdEx = entryPreIndex
11964					skippy, err := skipGenerated(dAtA[iNdEx:])
11965					if err != nil {
11966						return err
11967					}
11968					if skippy < 0 {
11969						return ErrInvalidLengthGenerated
11970					}
11971					if (iNdEx + skippy) > postIndex {
11972						return io.ErrUnexpectedEOF
11973					}
11974					iNdEx += skippy
11975				}
11976			}
11977			m.Selector[mapkey] = mapvalue
11978			iNdEx = postIndex
11979		case 3:
11980			if wireType != 2 {
11981				return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
11982			}
11983			var stringLen uint64
11984			for shift := uint(0); ; shift += 7 {
11985				if shift >= 64 {
11986					return ErrIntOverflowGenerated
11987				}
11988				if iNdEx >= l {
11989					return io.ErrUnexpectedEOF
11990				}
11991				b := dAtA[iNdEx]
11992				iNdEx++
11993				stringLen |= (uint64(b) & 0x7F) << shift
11994				if b < 0x80 {
11995					break
11996				}
11997			}
11998			intStringLen := int(stringLen)
11999			if intStringLen < 0 {
12000				return ErrInvalidLengthGenerated
12001			}
12002			postIndex := iNdEx + intStringLen
12003			if postIndex > l {
12004				return io.ErrUnexpectedEOF
12005			}
12006			m.TargetSelector = string(dAtA[iNdEx:postIndex])
12007			iNdEx = postIndex
12008		default:
12009			iNdEx = preIndex
12010			skippy, err := skipGenerated(dAtA[iNdEx:])
12011			if err != nil {
12012				return err
12013			}
12014			if skippy < 0 {
12015				return ErrInvalidLengthGenerated
12016			}
12017			if (iNdEx + skippy) > l {
12018				return io.ErrUnexpectedEOF
12019			}
12020			iNdEx += skippy
12021		}
12022	}
12023
12024	if iNdEx > l {
12025		return io.ErrUnexpectedEOF
12026	}
12027	return nil
12028}
12029func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error {
12030	l := len(dAtA)
12031	iNdEx := 0
12032	for iNdEx < l {
12033		preIndex := iNdEx
12034		var wire uint64
12035		for shift := uint(0); ; shift += 7 {
12036			if shift >= 64 {
12037				return ErrIntOverflowGenerated
12038			}
12039			if iNdEx >= l {
12040				return io.ErrUnexpectedEOF
12041			}
12042			b := dAtA[iNdEx]
12043			iNdEx++
12044			wire |= (uint64(b) & 0x7F) << shift
12045			if b < 0x80 {
12046				break
12047			}
12048		}
12049		fieldNum := int32(wire >> 3)
12050		wireType := int(wire & 0x7)
12051		if wireType == 4 {
12052			return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group")
12053		}
12054		if fieldNum <= 0 {
12055			return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire)
12056		}
12057		switch fieldNum {
12058		case 1:
12059			if wireType != 2 {
12060				return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
12061			}
12062			var stringLen uint64
12063			for shift := uint(0); ; shift += 7 {
12064				if shift >= 64 {
12065					return ErrIntOverflowGenerated
12066				}
12067				if iNdEx >= l {
12068					return io.ErrUnexpectedEOF
12069				}
12070				b := dAtA[iNdEx]
12071				iNdEx++
12072				stringLen |= (uint64(b) & 0x7F) << shift
12073				if b < 0x80 {
12074					break
12075				}
12076			}
12077			intStringLen := int(stringLen)
12078			if intStringLen < 0 {
12079				return ErrInvalidLengthGenerated
12080			}
12081			postIndex := iNdEx + intStringLen
12082			if postIndex > l {
12083				return io.ErrUnexpectedEOF
12084			}
12085			m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex])
12086			iNdEx = postIndex
12087		case 2:
12088			if wireType != 2 {
12089				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
12090			}
12091			var msglen int
12092			for shift := uint(0); ; shift += 7 {
12093				if shift >= 64 {
12094					return ErrIntOverflowGenerated
12095				}
12096				if iNdEx >= l {
12097					return io.ErrUnexpectedEOF
12098				}
12099				b := dAtA[iNdEx]
12100				iNdEx++
12101				msglen |= (int(b) & 0x7F) << shift
12102				if b < 0x80 {
12103					break
12104				}
12105			}
12106			if msglen < 0 {
12107				return ErrInvalidLengthGenerated
12108			}
12109			postIndex := iNdEx + msglen
12110			if postIndex > l {
12111				return io.ErrUnexpectedEOF
12112			}
12113			m.Ranges = append(m.Ranges, IDRange{})
12114			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
12115				return err
12116			}
12117			iNdEx = postIndex
12118		default:
12119			iNdEx = preIndex
12120			skippy, err := skipGenerated(dAtA[iNdEx:])
12121			if err != nil {
12122				return err
12123			}
12124			if skippy < 0 {
12125				return ErrInvalidLengthGenerated
12126			}
12127			if (iNdEx + skippy) > l {
12128				return io.ErrUnexpectedEOF
12129			}
12130			iNdEx += skippy
12131		}
12132	}
12133
12134	if iNdEx > l {
12135		return io.ErrUnexpectedEOF
12136	}
12137	return nil
12138}
12139func skipGenerated(dAtA []byte) (n int, err error) {
12140	l := len(dAtA)
12141	iNdEx := 0
12142	for iNdEx < l {
12143		var wire uint64
12144		for shift := uint(0); ; shift += 7 {
12145			if shift >= 64 {
12146				return 0, ErrIntOverflowGenerated
12147			}
12148			if iNdEx >= l {
12149				return 0, io.ErrUnexpectedEOF
12150			}
12151			b := dAtA[iNdEx]
12152			iNdEx++
12153			wire |= (uint64(b) & 0x7F) << shift
12154			if b < 0x80 {
12155				break
12156			}
12157		}
12158		wireType := int(wire & 0x7)
12159		switch wireType {
12160		case 0:
12161			for shift := uint(0); ; shift += 7 {
12162				if shift >= 64 {
12163					return 0, ErrIntOverflowGenerated
12164				}
12165				if iNdEx >= l {
12166					return 0, io.ErrUnexpectedEOF
12167				}
12168				iNdEx++
12169				if dAtA[iNdEx-1] < 0x80 {
12170					break
12171				}
12172			}
12173			return iNdEx, nil
12174		case 1:
12175			iNdEx += 8
12176			return iNdEx, nil
12177		case 2:
12178			var length int
12179			for shift := uint(0); ; shift += 7 {
12180				if shift >= 64 {
12181					return 0, ErrIntOverflowGenerated
12182				}
12183				if iNdEx >= l {
12184					return 0, io.ErrUnexpectedEOF
12185				}
12186				b := dAtA[iNdEx]
12187				iNdEx++
12188				length |= (int(b) & 0x7F) << shift
12189				if b < 0x80 {
12190					break
12191				}
12192			}
12193			iNdEx += length
12194			if length < 0 {
12195				return 0, ErrInvalidLengthGenerated
12196			}
12197			return iNdEx, nil
12198		case 3:
12199			for {
12200				var innerWire uint64
12201				var start int = iNdEx
12202				for shift := uint(0); ; shift += 7 {
12203					if shift >= 64 {
12204						return 0, ErrIntOverflowGenerated
12205					}
12206					if iNdEx >= l {
12207						return 0, io.ErrUnexpectedEOF
12208					}
12209					b := dAtA[iNdEx]
12210					iNdEx++
12211					innerWire |= (uint64(b) & 0x7F) << shift
12212					if b < 0x80 {
12213						break
12214					}
12215				}
12216				innerWireType := int(innerWire & 0x7)
12217				if innerWireType == 4 {
12218					break
12219				}
12220				next, err := skipGenerated(dAtA[start:])
12221				if err != nil {
12222					return 0, err
12223				}
12224				iNdEx = start + next
12225			}
12226			return iNdEx, nil
12227		case 4:
12228			return iNdEx, nil
12229		case 5:
12230			iNdEx += 4
12231			return iNdEx, nil
12232		default:
12233			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
12234		}
12235	}
12236	panic("unreachable")
12237}
12238
12239var (
12240	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
12241	ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
12242)
12243
12244func init() {
12245	proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptorGenerated)
12246}
12247
12248var fileDescriptorGenerated = []byte{
12249	// 3622 bytes of a gzipped FileDescriptorProto
12250	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x6f, 0x1c, 0x47,
12251	0x76, 0x57, 0xcf, 0x0c, 0x39, 0xc3, 0x47, 0xf1, 0xab, 0x48, 0x91, 0x63, 0xc9, 0xe2, 0xc8, 0x6d,
12252	0x40, 0x91, 0x1d, 0x69, 0xc6, 0x92, 0x25, 0x59, 0xb1, 0x10, 0xdb, 0x1c, 0x52, 0x94, 0xe8, 0xf0,
12253	0x63, 0x5c, 0x43, 0x2a, 0x86, 0x11, 0x3b, 0x6e, 0xce, 0x14, 0x87, 0x2d, 0xf6, 0x74, 0xb7, 0xbb,
12254	0x6b, 0x68, 0x0e, 0x90, 0x43, 0x0e, 0x41, 0x80, 0x00, 0x09, 0x92, 0x8b, 0x93, 0x1c, 0x63, 0x04,
12255	0xc8, 0x29, 0x41, 0x72, 0xcb, 0x1e, 0x0c, 0x03, 0x0b, 0x78, 0x01, 0x61, 0xe1, 0x05, 0x7c, 0x5b,
12256	0x9f, 0x88, 0x35, 0x7d, 0x5a, 0xec, 0x3f, 0xb0, 0xd0, 0x61, 0x77, 0x51, 0xd5, 0xd5, 0xdf, 0xdd,
12257	0x9a, 0x26, 0x2d, 0x11, 0x8b, 0xc5, 0xde, 0x38, 0xf5, 0xde, 0xfb, 0xbd, 0x57, 0x55, 0xaf, 0xde,
12258	0x7b, 0x5d, 0xf5, 0x08, 0xcb, 0x7b, 0x77, 0xec, 0xaa, 0x6a, 0xd4, 0xf6, 0x7a, 0xdb, 0xc4, 0xd2,
12259	0x09, 0x25, 0x76, 0x6d, 0x9f, 0xe8, 0x6d, 0xc3, 0xaa, 0x09, 0x82, 0x62, 0xaa, 0x35, 0x72, 0x40,
12260	0x89, 0x6e, 0xab, 0x86, 0x6e, 0xd7, 0xf6, 0xaf, 0x6f, 0x13, 0xaa, 0x5c, 0xaf, 0x75, 0x88, 0x4e,
12261	0x2c, 0x85, 0x92, 0x76, 0xd5, 0xb4, 0x0c, 0x6a, 0xa0, 0x8b, 0x0e, 0x7b, 0x55, 0x31, 0xd5, 0xaa,
12262	0xcf, 0x5e, 0x15, 0xec, 0xe7, 0xaf, 0x75, 0x54, 0xba, 0xdb, 0xdb, 0xae, 0xb6, 0x8c, 0x6e, 0xad,
12263	0x63, 0x74, 0x8c, 0x1a, 0x97, 0xda, 0xee, 0xed, 0xf0, 0x5f, 0xfc, 0x07, 0xff, 0xcb, 0x41, 0x3b,
12264	0x2f, 0x07, 0x94, 0xb7, 0x0c, 0x8b, 0xd4, 0xf6, 0x63, 0x1a, 0xcf, 0xdf, 0xf4, 0x79, 0xba, 0x4a,
12265	0x6b, 0x57, 0xd5, 0x89, 0xd5, 0xaf, 0x99, 0x7b, 0x1d, 0x36, 0x60, 0xd7, 0xba, 0x84, 0x2a, 0x49,
12266	0x52, 0xb5, 0x34, 0x29, 0xab, 0xa7, 0x53, 0xb5, 0x4b, 0x62, 0x02, 0xb7, 0x07, 0x09, 0xd8, 0xad,
12267	0x5d, 0xd2, 0x55, 0x62, 0x72, 0xaf, 0xa7, 0xc9, 0xf5, 0xa8, 0xaa, 0xd5, 0x54, 0x9d, 0xda, 0xd4,
12268	0x8a, 0x0a, 0xc9, 0x37, 0x61, 0x72, 0x41, 0xd3, 0x8c, 0x4f, 0x49, 0x7b, 0xb1, 0xb9, 0xb2, 0x64,
12269	0xa9, 0xfb, 0xc4, 0x42, 0x97, 0xa0, 0xa0, 0x2b, 0x5d, 0x52, 0x96, 0x2e, 0x49, 0x57, 0x46, 0xea,
12270	0x67, 0x1f, 0x1f, 0x56, 0xce, 0x1c, 0x1d, 0x56, 0x0a, 0xeb, 0x4a, 0x97, 0x60, 0x4e, 0x91, 0xef,
12271	0xc2, 0x94, 0x90, 0x5a, 0xd6, 0xc8, 0xc1, 0x43, 0x43, 0xeb, 0x75, 0x09, 0xba, 0x0c, 0xc3, 0x6d,
12272	0x0e, 0x20, 0x04, 0xc7, 0x85, 0xe0, 0xb0, 0x03, 0x8b, 0x05, 0x55, 0xb6, 0x61, 0x42, 0x08, 0x3f,
12273	0x30, 0x6c, 0xda, 0x50, 0xe8, 0x2e, 0xba, 0x01, 0x60, 0x2a, 0x74, 0xb7, 0x61, 0x91, 0x1d, 0xf5,
12274	0x40, 0x88, 0x23, 0x21, 0x0e, 0x0d, 0x8f, 0x82, 0x03, 0x5c, 0xe8, 0x2a, 0x94, 0x2c, 0xa2, 0xb4,
12275	0x37, 0x74, 0xad, 0x5f, 0xce, 0x5d, 0x92, 0xae, 0x94, 0xea, 0x93, 0x42, 0xa2, 0x84, 0xc5, 0x38,
12276	0xf6, 0x38, 0xe4, 0xcf, 0x72, 0x30, 0xb2, 0xa4, 0x90, 0xae, 0xa1, 0x37, 0x09, 0x45, 0x1f, 0x43,
12277	0x89, 0x6d, 0x57, 0x5b, 0xa1, 0x0a, 0xd7, 0x36, 0x7a, 0xe3, 0xb5, 0xaa, 0xef, 0x4e, 0xde, 0xea,
12278	0x55, 0xcd, 0xbd, 0x0e, 0x1b, 0xb0, 0xab, 0x8c, 0xbb, 0xba, 0x7f, 0xbd, 0xba, 0xb1, 0xfd, 0x88,
12279	0xb4, 0xe8, 0x1a, 0xa1, 0x8a, 0x6f, 0x9f, 0x3f, 0x86, 0x3d, 0x54, 0xb4, 0x0e, 0x05, 0xdb, 0x24,
12280	0x2d, 0x6e, 0xd9, 0xe8, 0x8d, 0xab, 0xd5, 0xa7, 0x3a, 0x6b, 0xd5, 0xb3, 0xac, 0x69, 0x92, 0x96,
12281	0xbf, 0xe2, 0xec, 0x17, 0xe6, 0x38, 0xe8, 0x21, 0x0c, 0xdb, 0x54, 0xa1, 0x3d, 0xbb, 0x9c, 0xe7,
12282	0x88, 0xd5, 0xcc, 0x88, 0x5c, 0xca, 0xdf, 0x0c, 0xe7, 0x37, 0x16, 0x68, 0xf2, 0x2f, 0x73, 0x80,
12283	0x3c, 0xde, 0x45, 0x43, 0x6f, 0xab, 0x54, 0x35, 0x74, 0xf4, 0x26, 0x14, 0x68, 0xdf, 0x74, 0x5d,
12284	0xe0, 0xb2, 0x6b, 0xd0, 0x66, 0xdf, 0x24, 0x4f, 0x0e, 0x2b, 0xb3, 0x71, 0x09, 0x46, 0xc1, 0x5c,
12285	0x06, 0xad, 0x7a, 0xa6, 0xe6, 0xb8, 0xf4, 0xcd, 0xb0, 0xea, 0x27, 0x87, 0x95, 0x84, 0xc3, 0x56,
12286	0xf5, 0x90, 0xc2, 0x06, 0xa2, 0x7d, 0x40, 0x9a, 0x62, 0xd3, 0x4d, 0x4b, 0xd1, 0x6d, 0x47, 0x93,
12287	0xda, 0x25, 0x62, 0x11, 0x5e, 0xcd, 0xb6, 0x69, 0x4c, 0xa2, 0x7e, 0x5e, 0x58, 0x81, 0x56, 0x63,
12288	0x68, 0x38, 0x41, 0x03, 0xf3, 0x66, 0x8b, 0x28, 0xb6, 0xa1, 0x97, 0x0b, 0x61, 0x6f, 0xc6, 0x7c,
12289	0x14, 0x0b, 0x2a, 0x7a, 0x05, 0x8a, 0x5d, 0x62, 0xdb, 0x4a, 0x87, 0x94, 0x87, 0x38, 0xe3, 0x84,
12290	0x60, 0x2c, 0xae, 0x39, 0xc3, 0xd8, 0xa5, 0xcb, 0x5f, 0x48, 0x30, 0xe6, 0xad, 0xdc, 0xaa, 0x6a,
12291	0x53, 0xf4, 0x57, 0x31, 0x3f, 0xac, 0x66, 0x9b, 0x12, 0x93, 0xe6, 0x5e, 0xe8, 0xf9, 0xbc, 0x3b,
12292	0x12, 0xf0, 0xc1, 0x35, 0x18, 0x52, 0x29, 0xe9, 0xb2, 0x7d, 0xc8, 0x5f, 0x19, 0xbd, 0x71, 0x25,
12293	0xab, 0xcb, 0xd4, 0xc7, 0x04, 0xe8, 0xd0, 0x0a, 0x13, 0xc7, 0x0e, 0x8a, 0xfc, 0xaf, 0x85, 0x80,
12294	0xf9, 0xcc, 0x35, 0xd1, 0x87, 0x50, 0xb2, 0x89, 0x46, 0x5a, 0xd4, 0xb0, 0x84, 0xf9, 0xaf, 0x67,
12295	0x34, 0x5f, 0xd9, 0x26, 0x5a, 0x53, 0x88, 0xd6, 0xcf, 0x32, 0xfb, 0xdd, 0x5f, 0xd8, 0x83, 0x44,
12296	0xef, 0x41, 0x89, 0x92, 0xae, 0xa9, 0x29, 0x94, 0x88, 0x73, 0xf4, 0x72, 0x70, 0x0a, 0xcc, 0x73,
12297	0x18, 0x58, 0xc3, 0x68, 0x6f, 0x0a, 0x36, 0x7e, 0x7c, 0xbc, 0x25, 0x71, 0x47, 0xb1, 0x07, 0x83,
12298	0xf6, 0x61, 0xbc, 0x67, 0xb6, 0x19, 0x27, 0x65, 0x51, 0xb0, 0xd3, 0x17, 0x9e, 0x74, 0x3b, 0xeb,
12299	0xda, 0x6c, 0x85, 0xa4, 0xeb, 0xb3, 0x42, 0xd7, 0x78, 0x78, 0x1c, 0x47, 0xb4, 0xa0, 0x05, 0x98,
12300	0xe8, 0xaa, 0x3a, 0x8b, 0x4b, 0xfd, 0x26, 0x69, 0x19, 0x7a, 0xdb, 0xe6, 0x6e, 0x35, 0x54, 0x9f,
12301	0x13, 0x00, 0x13, 0x6b, 0x61, 0x32, 0x8e, 0xf2, 0xa3, 0x77, 0x01, 0xb9, 0xd3, 0xb8, 0xef, 0x04,
12302	0x71, 0xd5, 0xd0, 0xb9, 0xcf, 0xe5, 0x7d, 0xe7, 0xde, 0x8c, 0x71, 0xe0, 0x04, 0x29, 0xb4, 0x0a,
12303	0x33, 0x16, 0xd9, 0x57, 0xd9, 0x1c, 0x1f, 0xa8, 0x36, 0x35, 0xac, 0xfe, 0xaa, 0xda, 0x55, 0x69,
12304	0x79, 0x98, 0xdb, 0x54, 0x3e, 0x3a, 0xac, 0xcc, 0xe0, 0x04, 0x3a, 0x4e, 0x94, 0x92, 0xff, 0x6d,
12305	0x18, 0x26, 0x22, 0xf1, 0x06, 0x3d, 0x84, 0xd9, 0x56, 0xcf, 0xb2, 0x88, 0x4e, 0xd7, 0x7b, 0xdd,
12306	0x6d, 0x62, 0x35, 0x5b, 0xbb, 0xa4, 0xdd, 0xd3, 0x48, 0x9b, 0x3b, 0xca, 0x50, 0x7d, 0x5e, 0x58,
12307	0x3c, 0xbb, 0x98, 0xc8, 0x85, 0x53, 0xa4, 0xd9, 0x2a, 0xe8, 0x7c, 0x68, 0x4d, 0xb5, 0x6d, 0x0f,
12308	0x33, 0xc7, 0x31, 0xbd, 0x55, 0x58, 0x8f, 0x71, 0xe0, 0x04, 0x29, 0x66, 0x63, 0x9b, 0xd8, 0xaa,
12309	0x45, 0xda, 0x51, 0x1b, 0xf3, 0x61, 0x1b, 0x97, 0x12, 0xb9, 0x70, 0x8a, 0x34, 0xba, 0x05, 0xa3,
12310	0x8e, 0x36, 0xbe, 0x7f, 0x62, 0xa3, 0xa7, 0x05, 0xd8, 0xe8, 0xba, 0x4f, 0xc2, 0x41, 0x3e, 0x36,
12311	0x35, 0x63, 0xdb, 0x26, 0xd6, 0x3e, 0x69, 0xa7, 0x6f, 0xf0, 0x46, 0x8c, 0x03, 0x27, 0x48, 0xb1,
12312	0xa9, 0x39, 0x1e, 0x18, 0x9b, 0xda, 0x70, 0x78, 0x6a, 0x5b, 0x89, 0x5c, 0x38, 0x45, 0x9a, 0xf9,
12313	0xb1, 0x63, 0xf2, 0xc2, 0xbe, 0xa2, 0x6a, 0xca, 0xb6, 0x46, 0xca, 0xc5, 0xb0, 0x1f, 0xaf, 0x87,
12314	0xc9, 0x38, 0xca, 0x8f, 0xee, 0xc3, 0x94, 0x33, 0xb4, 0xa5, 0x2b, 0x1e, 0x48, 0x89, 0x83, 0xbc,
12315	0x20, 0x40, 0xa6, 0xd6, 0xa3, 0x0c, 0x38, 0x2e, 0x83, 0xde, 0x84, 0xf1, 0x96, 0xa1, 0x69, 0xdc,
12316	0x1f, 0x17, 0x8d, 0x9e, 0x4e, 0xcb, 0x23, 0x1c, 0x05, 0xb1, 0xf3, 0xb8, 0x18, 0xa2, 0xe0, 0x08,
12317	0x27, 0x22, 0x00, 0x2d, 0x37, 0xe1, 0xd8, 0x65, 0xe0, 0xf1, 0xf1, 0x7a, 0xd6, 0x18, 0xe0, 0xa5,
12318	0x2a, 0xbf, 0x06, 0xf0, 0x86, 0x6c, 0x1c, 0x00, 0x96, 0x7f, 0x2a, 0xc1, 0x5c, 0x4a, 0xe8, 0x40,
12319	0x6f, 0x87, 0x52, 0xec, 0x9f, 0x46, 0x52, 0xec, 0x85, 0x14, 0xb1, 0x40, 0x9e, 0xd5, 0x61, 0xcc,
12320	0x62, 0xb3, 0xd2, 0x3b, 0x0e, 0x8b, 0x88, 0x91, 0xb7, 0x06, 0x4c, 0x03, 0x07, 0x65, 0xfc, 0x98,
12321	0x3f, 0x75, 0x74, 0x58, 0x19, 0x0b, 0xd1, 0x70, 0x18, 0x5e, 0xfe, 0xf7, 0x1c, 0xc0, 0x12, 0x31,
12322	0x35, 0xa3, 0xdf, 0x25, 0xfa, 0x69, 0xd4, 0x50, 0x1b, 0xa1, 0x1a, 0xea, 0xda, 0xa0, 0xed, 0xf1,
12323	0x4c, 0x4b, 0x2d, 0xa2, 0xfe, 0x32, 0x52, 0x44, 0xd5, 0xb2, 0x43, 0x3e, 0xbd, 0x8a, 0xfa, 0x79,
12324	0x1e, 0xa6, 0x7d, 0x66, 0xbf, 0x8c, 0xba, 0x1b, 0xda, 0xe3, 0x3f, 0x89, 0xec, 0xf1, 0x5c, 0x82,
12325	0xc8, 0x73, 0xab, 0xa3, 0x9e, 0x7d, 0x3d, 0x83, 0x1e, 0xc1, 0x38, 0x2b, 0x9c, 0x1c, 0xf7, 0xe0,
12326	0x65, 0xd9, 0xf0, 0xb1, 0xcb, 0x32, 0x2f, 0x81, 0xae, 0x86, 0x90, 0x70, 0x04, 0x39, 0xa5, 0x0c,
12327	0x2c, 0x3e, 0xef, 0x32, 0x50, 0xfe, 0x52, 0x82, 0x71, 0x7f, 0x9b, 0x4e, 0xa1, 0x68, 0x5b, 0x0f,
12328	0x17, 0x6d, 0xaf, 0x64, 0x76, 0xd1, 0x94, 0xaa, 0xed, 0xd7, 0xac, 0xc0, 0xf7, 0x98, 0xd8, 0x01,
12329	0xdf, 0x56, 0x5a, 0x7b, 0x83, 0xbf, 0xf1, 0xd0, 0x67, 0x12, 0x20, 0x91, 0x05, 0x16, 0x74, 0xdd,
12330	0xa0, 0x8a, 0x13, 0x2b, 0x1d, 0xb3, 0x56, 0x32, 0x9b, 0xe5, 0x6a, 0xac, 0x6e, 0xc5, 0xb0, 0xee,
12331	0xe9, 0xd4, 0xea, 0xfb, 0x3b, 0x12, 0x67, 0xc0, 0x09, 0x06, 0x20, 0x05, 0xc0, 0x12, 0x98, 0x9b,
12332	0x86, 0x38, 0xc8, 0xd7, 0x32, 0xc4, 0x3c, 0x26, 0xb0, 0x68, 0xe8, 0x3b, 0x6a, 0xc7, 0x0f, 0x3b,
12333	0xd8, 0x03, 0xc2, 0x01, 0xd0, 0xf3, 0xf7, 0x60, 0x2e, 0xc5, 0x5a, 0x34, 0x09, 0xf9, 0x3d, 0xd2,
12334	0x77, 0x96, 0x0d, 0xb3, 0x3f, 0xd1, 0x0c, 0x0c, 0xed, 0x2b, 0x5a, 0xcf, 0x09, 0xbf, 0x23, 0xd8,
12335	0xf9, 0xf1, 0x66, 0xee, 0x8e, 0x24, 0x7f, 0x31, 0x14, 0xf4, 0x1d, 0x5e, 0x31, 0x5f, 0x61, 0x1f,
12336	0xad, 0xa6, 0xa6, 0xb6, 0x14, 0x5b, 0x14, 0x42, 0x67, 0x9d, 0x0f, 0x56, 0x67, 0x0c, 0x7b, 0xd4,
12337	0x50, 0x6d, 0x9d, 0x7b, 0xbe, 0xb5, 0x75, 0xfe, 0xd9, 0xd4, 0xd6, 0x7f, 0x0d, 0x25, 0xdb, 0xad,
12338	0xaa, 0x0b, 0x1c, 0xf2, 0xfa, 0x31, 0xe2, 0xab, 0x28, 0xa8, 0x3d, 0x05, 0x5e, 0x29, 0xed, 0x81,
12339	0x26, 0x15, 0xd1, 0x43, 0xc7, 0x2c, 0xa2, 0x9f, 0x69, 0xe1, 0xcb, 0x62, 0xaa, 0xa9, 0xf4, 0x6c,
12340	0xd2, 0xe6, 0x81, 0xa8, 0xe4, 0xc7, 0xd4, 0x06, 0x1f, 0xc5, 0x82, 0x8a, 0x3e, 0x0c, 0xb9, 0x6c,
12341	0xe9, 0x24, 0x2e, 0x3b, 0x9e, 0xee, 0xae, 0x68, 0x0b, 0xe6, 0x4c, 0xcb, 0xe8, 0x58, 0xc4, 0xb6,
12342	0x97, 0x88, 0xd2, 0xd6, 0x54, 0x9d, 0xb8, 0xeb, 0xe3, 0x54, 0x44, 0x17, 0x8e, 0x0e, 0x2b, 0x73,
12343	0x8d, 0x64, 0x16, 0x9c, 0x26, 0x2b, 0x3f, 0x2e, 0xc0, 0x64, 0x34, 0x03, 0xa6, 0x14, 0xa9, 0xd2,
12344	0x89, 0x8a, 0xd4, 0xab, 0x81, 0xc3, 0xe0, 0x54, 0xf0, 0x81, 0x1b, 0x9c, 0xd8, 0x81, 0x58, 0x80,
12345	0x09, 0x11, 0x0d, 0x5c, 0xa2, 0x28, 0xd3, 0xbd, 0xdd, 0xdf, 0x0a, 0x93, 0x71, 0x94, 0x9f, 0x95,
12346	0x9e, 0x7e, 0x45, 0xe9, 0x82, 0x14, 0xc2, 0xa5, 0xe7, 0x42, 0x94, 0x01, 0xc7, 0x65, 0xd0, 0x1a,
12347	0x4c, 0xf7, 0xf4, 0x38, 0x94, 0xe3, 0x8d, 0x17, 0x04, 0xd4, 0xf4, 0x56, 0x9c, 0x05, 0x27, 0xc9,
12348	0xa1, 0x9d, 0x50, 0x35, 0x3a, 0xcc, 0x23, 0xec, 0x8d, 0xcc, 0x67, 0x27, 0x73, 0x39, 0x8a, 0xee,
12349	0xc2, 0x98, 0xc5, 0xbf, 0x3b, 0x5c, 0x83, 0x9d, 0xda, 0xfd, 0x9c, 0x10, 0x1b, 0xc3, 0x41, 0x22,
12350	0x0e, 0xf3, 0x26, 0x94, 0xdb, 0xa5, 0xac, 0xe5, 0xb6, 0xfc, 0x63, 0x29, 0x98, 0x84, 0xbc, 0x12,
12351	0x78, 0xd0, 0x2d, 0x53, 0x4c, 0x22, 0x50, 0x1d, 0x19, 0xc9, 0xd5, 0xef, 0xed, 0x63, 0x55, 0xbf,
12352	0x7e, 0xf2, 0x1c, 0x5c, 0xfe, 0x7e, 0x2e, 0xc1, 0xec, 0x72, 0xf3, 0xbe, 0x65, 0xf4, 0x4c, 0xd7,
12353	0x9c, 0x0d, 0xd3, 0x59, 0xd7, 0x37, 0xa0, 0x60, 0xf5, 0x34, 0x77, 0x1e, 0x2f, 0xbb, 0xf3, 0xc0,
12354	0x3d, 0x8d, 0xcd, 0x63, 0x3a, 0x22, 0xe5, 0x4c, 0x82, 0x09, 0xa0, 0x75, 0x18, 0xb6, 0x14, 0xbd,
12355	0x43, 0xdc, 0xb4, 0x7a, 0x79, 0x80, 0xf5, 0x2b, 0x4b, 0x98, 0xb1, 0x07, 0x8a, 0x37, 0x2e, 0x8d,
12356	0x05, 0x8a, 0xfc, 0x4f, 0x12, 0x4c, 0x3c, 0xd8, 0xdc, 0x6c, 0xac, 0xe8, 0xfc, 0x44, 0xf3, 0xbb,
12357	0xd5, 0x4b, 0x50, 0x30, 0x15, 0xba, 0x1b, 0xcd, 0xf4, 0x8c, 0x86, 0x39, 0x05, 0xbd, 0x0f, 0x45,
12358	0x16, 0x49, 0x88, 0xde, 0xce, 0x58, 0x6a, 0x0b, 0xf8, 0xba, 0x23, 0xe4, 0x57, 0x88, 0x62, 0x00,
12359	0xbb, 0x70, 0xf2, 0x1e, 0xcc, 0x04, 0xcc, 0x61, 0xeb, 0xf1, 0x90, 0x65, 0x47, 0xd4, 0x84, 0x21,
12360	0xa6, 0x99, 0xe5, 0xc0, 0x7c, 0x86, 0xcb, 0xcc, 0xc8, 0x94, 0xfc, 0x4a, 0x87, 0xfd, 0xb2, 0xb1,
12361	0x83, 0x25, 0xaf, 0xc1, 0x18, 0xbf, 0x50, 0x36, 0x2c, 0xca, 0x97, 0x05, 0x5d, 0x84, 0x7c, 0x57,
12362	0xd5, 0x45, 0x9e, 0x1d, 0x15, 0x32, 0x79, 0x96, 0x23, 0xd8, 0x38, 0x27, 0x2b, 0x07, 0x22, 0xf2,
12363	0xf8, 0x64, 0xe5, 0x00, 0xb3, 0x71, 0xf9, 0x3e, 0x14, 0xc5, 0x72, 0x07, 0x81, 0xf2, 0x4f, 0x07,
12364	0xca, 0x27, 0x00, 0x6d, 0x40, 0x71, 0xa5, 0x51, 0xd7, 0x0c, 0xa7, 0xea, 0x6a, 0xa9, 0x6d, 0x2b,
12365	0xba, 0x17, 0x8b, 0x2b, 0x4b, 0x18, 0x73, 0x0a, 0x92, 0x61, 0x98, 0x1c, 0xb4, 0x88, 0x49, 0xb9,
12366	0x47, 0x8c, 0xd4, 0x81, 0xed, 0xf2, 0x3d, 0x3e, 0x82, 0x05, 0x45, 0xfe, 0xe7, 0x1c, 0x14, 0xc5,
12367	0x72, 0x9c, 0xc2, 0x57, 0xd8, 0x6a, 0xe8, 0x2b, 0xec, 0xd5, 0x6c, 0xae, 0x91, 0xfa, 0x09, 0xb6,
12368	0x19, 0xf9, 0x04, 0xbb, 0x9a, 0x11, 0xef, 0xe9, 0xdf, 0x5f, 0xff, 0x27, 0xc1, 0x78, 0xd8, 0x29,
12369	0xd1, 0x2d, 0x18, 0x65, 0x09, 0x47, 0x6d, 0x91, 0x75, 0xbf, 0xce, 0xf5, 0x2e, 0x61, 0x9a, 0x3e,
12370	0x09, 0x07, 0xf9, 0x50, 0xc7, 0x13, 0x63, 0x7e, 0x24, 0x26, 0x9d, 0xbe, 0xa4, 0x3d, 0xaa, 0x6a,
12371	0x55, 0xe7, 0x69, 0xa5, 0xba, 0xa2, 0xd3, 0x0d, 0xab, 0x49, 0x2d, 0x55, 0xef, 0xc4, 0x14, 0x71,
12372	0xa7, 0x0c, 0x22, 0xcb, 0x3f, 0x92, 0x60, 0x54, 0x98, 0x7c, 0x0a, 0x5f, 0x15, 0x7f, 0x11, 0xfe,
12373	0xaa, 0xb8, 0x9c, 0xf1, 0x80, 0x27, 0x7f, 0x52, 0xfc, 0x97, 0x6f, 0x3a, 0x3b, 0xd2, 0xcc, 0xab,
12374	0x77, 0x0d, 0x9b, 0x46, 0xbd, 0x9a, 0x1d, 0x46, 0xcc, 0x29, 0xa8, 0x07, 0x93, 0x6a, 0x24, 0x06,
12375	0x88, 0xa5, 0xad, 0x65, 0xb3, 0xc4, 0x13, 0xab, 0x97, 0x05, 0xfc, 0x64, 0x94, 0x82, 0x63, 0x2a,
12376	0x64, 0x02, 0x31, 0x2e, 0xf4, 0x1e, 0x14, 0x76, 0x29, 0x35, 0x13, 0xee, 0xab, 0x07, 0x44, 0x1e,
12377	0xdf, 0x84, 0x12, 0x9f, 0xdd, 0xe6, 0x66, 0x03, 0x73, 0x28, 0xf9, 0x37, 0xfe, 0x7a, 0x34, 0x1d,
12378	0x1f, 0xf7, 0xe2, 0xa9, 0x74, 0x92, 0x78, 0x3a, 0x9a, 0x14, 0x4b, 0xd1, 0x03, 0xc8, 0x53, 0x2d,
12379	0xeb, 0x67, 0xa1, 0x40, 0xdc, 0x5c, 0x6d, 0xfa, 0x01, 0x69, 0x73, 0xb5, 0x89, 0x19, 0x04, 0xda,
12380	0x80, 0x21, 0x96, 0x7d, 0xd8, 0x11, 0xcc, 0x67, 0x3f, 0xd2, 0x6c, 0xfe, 0xbe, 0x43, 0xb0, 0x5f,
12381	0x36, 0x76, 0x70, 0xe4, 0x4f, 0x60, 0x2c, 0x74, 0x4e, 0xd1, 0xc7, 0x70, 0x56, 0x33, 0x94, 0x76,
12382	0x5d, 0xd1, 0x14, 0xbd, 0x45, 0xdc, 0xc7, 0x81, 0xcb, 0x49, 0x5f, 0x18, 0xab, 0x01, 0x3e, 0x71,
12383	0xca, 0x67, 0x84, 0x92, 0xb3, 0x41, 0x1a, 0x0e, 0x21, 0xca, 0x0a, 0x80, 0x3f, 0x47, 0x54, 0x81,
12384	0x21, 0xe6, 0x67, 0x4e, 0x3e, 0x19, 0xa9, 0x8f, 0x30, 0x0b, 0x99, 0xfb, 0xd9, 0xd8, 0x19, 0x47,
12385	0x37, 0x00, 0x6c, 0xd2, 0xb2, 0x08, 0xe5, 0xc1, 0x20, 0x17, 0x7e, 0x60, 0x6c, 0x7a, 0x14, 0x1c,
12386	0xe0, 0x92, 0x7f, 0x22, 0xc1, 0xd8, 0x3a, 0xa1, 0x9f, 0x1a, 0xd6, 0x5e, 0xc3, 0xd0, 0xd4, 0x56,
12387	0xff, 0x14, 0x82, 0x2d, 0x0e, 0x05, 0xdb, 0xd7, 0x06, 0xec, 0x4c, 0xc8, 0xba, 0xb4, 0x90, 0x2b,
12388	0x7f, 0x29, 0xc1, 0x5c, 0x88, 0xf3, 0x9e, 0x7f, 0x74, 0xb7, 0x60, 0xc8, 0x34, 0x2c, 0xea, 0x26,
12389	0xe2, 0x63, 0x29, 0x64, 0x61, 0x2c, 0x90, 0x8a, 0x19, 0x0c, 0x76, 0xd0, 0xd0, 0x2a, 0xe4, 0xa8,
12390	0x21, 0x5c, 0xf5, 0x78, 0x98, 0x84, 0x58, 0x75, 0x10, 0x98, 0xb9, 0x4d, 0x03, 0xe7, 0xa8, 0xc1,
12391	0x36, 0xa2, 0x1c, 0xe2, 0x0a, 0x06, 0x9f, 0xe7, 0x34, 0x03, 0x0c, 0x85, 0x1d, 0xcb, 0xe8, 0x9e,
12392	0x78, 0x0e, 0xde, 0x46, 0x2c, 0x5b, 0x46, 0x17, 0x73, 0x2c, 0xf9, 0x2b, 0x09, 0xa6, 0x42, 0x9c,
12393	0xa7, 0x10, 0xf8, 0xdf, 0x0b, 0x07, 0xfe, 0xab, 0xc7, 0x99, 0x48, 0x4a, 0xf8, 0xff, 0x2a, 0x17,
12394	0x99, 0x06, 0x9b, 0x30, 0xda, 0x81, 0x51, 0xd3, 0x68, 0x37, 0x9f, 0xc1, 0x73, 0xe0, 0x04, 0xcb,
12395	0x9b, 0x0d, 0x1f, 0x0b, 0x07, 0x81, 0xd1, 0x01, 0x4c, 0xe9, 0x4a, 0x97, 0xd8, 0xa6, 0xd2, 0x22,
12396	0xcd, 0x67, 0x70, 0x41, 0x72, 0x8e, 0xbf, 0x37, 0x44, 0x11, 0x71, 0x5c, 0x09, 0x5a, 0x83, 0xa2,
12397	0x6a, 0xf2, 0x3a, 0x4e, 0xd4, 0x2e, 0x03, 0xb3, 0xa8, 0x53, 0xf5, 0x39, 0xf1, 0x5c, 0xfc, 0xc0,
12398	0x2e, 0x86, 0xfc, 0xdf, 0x51, 0x6f, 0x60, 0xfe, 0x87, 0xee, 0x43, 0x89, 0x37, 0x66, 0xb4, 0x0c,
12399	0xcd, 0x7d, 0x19, 0x60, 0x3b, 0xdb, 0x10, 0x63, 0x4f, 0x0e, 0x2b, 0x17, 0x12, 0x2e, 0x7d, 0x5d,
12400	0x32, 0xf6, 0x84, 0xd1, 0x3a, 0x14, 0xcc, 0x1f, 0x52, 0xc1, 0xf0, 0x24, 0xc7, 0xcb, 0x16, 0x8e,
12401	0x23, 0xff, 0x5d, 0x3e, 0x62, 0x2e, 0x4f, 0x75, 0x8f, 0x9e, 0xd9, 0xae, 0x7b, 0x15, 0x53, 0xea,
12402	0xce, 0x6f, 0x43, 0x51, 0x64, 0x78, 0xe1, 0xcc, 0x6f, 0x1c, 0xc7, 0x99, 0x83, 0x59, 0xcc, 0xfb,
12403	0x60, 0x71, 0x07, 0x5d, 0x60, 0xf4, 0x11, 0x0c, 0x13, 0x47, 0x85, 0x93, 0x1b, 0x6f, 0x1f, 0x47,
12404	0x85, 0x1f, 0x57, 0xfd, 0x42, 0x55, 0x8c, 0x09, 0x54, 0xf4, 0x36, 0x5b, 0x2f, 0xc6, 0xcb, 0x3e,
12405	0x02, 0xed, 0x72, 0x81, 0xa7, 0xab, 0x8b, 0xce, 0xb4, 0xbd, 0xe1, 0x27, 0x87, 0x15, 0xf0, 0x7f,
12406	0xe2, 0xa0, 0x84, 0xfc, 0x33, 0x09, 0xa6, 0xf8, 0x0a, 0xb5, 0x7a, 0x96, 0x4a, 0xfb, 0xa7, 0x96,
12407	0x98, 0x1e, 0x86, 0x12, 0xd3, 0xcd, 0x01, 0xcb, 0x12, 0xb3, 0x30, 0x35, 0x39, 0x7d, 0x2d, 0xc1,
12408	0xb9, 0x18, 0xf7, 0x29, 0xc4, 0xc5, 0xad, 0x70, 0x5c, 0x7c, 0xed, 0xb8, 0x13, 0x4a, 0x89, 0x8d,
12409	0xbf, 0x9d, 0x4c, 0x98, 0x0e, 0x3f, 0x29, 0x37, 0x00, 0x4c, 0x4b, 0xdd, 0x57, 0x35, 0xd2, 0x11,
12410	0x8f, 0xe0, 0xa5, 0x40, 0x8b, 0x93, 0x47, 0xc1, 0x01, 0x2e, 0x64, 0xc3, 0x6c, 0x9b, 0xec, 0x28,
12411	0x3d, 0x8d, 0x2e, 0xb4, 0xdb, 0x8b, 0x8a, 0xa9, 0x6c, 0xab, 0x9a, 0x4a, 0x55, 0x71, 0x5d, 0x30,
12412	0x52, 0xbf, 0xeb, 0x3c, 0x4e, 0x27, 0x71, 0x3c, 0x39, 0xac, 0x5c, 0x4c, 0x7a, 0x1d, 0x72, 0x59,
12413	0xfa, 0x38, 0x05, 0x1a, 0xf5, 0xa1, 0x6c, 0x91, 0x4f, 0x7a, 0xaa, 0x45, 0xda, 0x4b, 0x96, 0x61,
12414	0x86, 0xd4, 0xe6, 0xb9, 0xda, 0x3f, 0x3f, 0x3a, 0xac, 0x94, 0x71, 0x0a, 0xcf, 0x60, 0xc5, 0xa9,
12415	0xf0, 0xe8, 0x11, 0x4c, 0x2b, 0xa2, 0x19, 0x2d, 0xa8, 0xd5, 0x39, 0x25, 0x77, 0x8e, 0x0e, 0x2b,
12416	0xd3, 0x0b, 0x71, 0xf2, 0x60, 0x85, 0x49, 0xa0, 0xa8, 0x06, 0xc5, 0x7d, 0xde, 0xb7, 0x66, 0x97,
12417	0x87, 0x38, 0x3e, 0x4b, 0x04, 0x45, 0xa7, 0x95, 0x8d, 0x61, 0x0e, 0x2f, 0x37, 0xf9, 0xe9, 0x73,
12418	0xb9, 0xd8, 0x07, 0x25, 0xab, 0x25, 0xc5, 0x89, 0xe7, 0x37, 0xc6, 0x25, 0x3f, 0x6a, 0x3d, 0xf0,
12419	0x49, 0x38, 0xc8, 0x87, 0x3e, 0x84, 0x91, 0x5d, 0x71, 0x2b, 0x61, 0x97, 0x8b, 0x99, 0x92, 0x70,
12420	0xe8, 0x16, 0xa3, 0x3e, 0x25, 0x54, 0x8c, 0xb8, 0xc3, 0x36, 0xf6, 0x11, 0xd1, 0x2b, 0x50, 0xe4,
12421	0x3f, 0x56, 0x96, 0xf8, 0x75, 0x5c, 0xc9, 0x8f, 0x6d, 0x0f, 0x9c, 0x61, 0xec, 0xd2, 0x5d, 0xd6,
12422	0x95, 0xc6, 0x22, 0xbf, 0x16, 0x8e, 0xb0, 0xae, 0x34, 0x16, 0xb1, 0x4b, 0x47, 0x1f, 0x43, 0xd1,
12423	0x26, 0xab, 0xaa, 0xde, 0x3b, 0x28, 0x43, 0xa6, 0x47, 0xe5, 0xe6, 0x3d, 0xce, 0x1d, 0xb9, 0x18,
12424	0xf3, 0x35, 0x08, 0x3a, 0x76, 0x61, 0xd1, 0x2e, 0x8c, 0x58, 0x3d, 0x7d, 0xc1, 0xde, 0xb2, 0x89,
12425	0x55, 0x1e, 0xe5, 0x3a, 0x06, 0x85, 0x73, 0xec, 0xf2, 0x47, 0xb5, 0x78, 0x2b, 0xe4, 0x71, 0x60,
12426	0x1f, 0x1c, 0xfd, 0xa3, 0x04, 0xc8, 0xee, 0x99, 0xa6, 0x46, 0xba, 0x44, 0xa7, 0x8a, 0xc6, 0xef,
12427	0xe2, 0xec, 0xf2, 0x59, 0xae, 0xf3, 0x9d, 0x41, 0xf3, 0x8a, 0x09, 0x46, 0x95, 0x7b, 0x97, 0xde,
12428	0x71, 0x56, 0x9c, 0xa0, 0x97, 0x2d, 0xed, 0x8e, 0xcd, 0xff, 0x2e, 0x8f, 0x65, 0x5a, 0xda, 0xe4,
12429	0x3b, 0x47, 0x7f, 0x69, 0x05, 0x1d, 0xbb, 0xb0, 0xe8, 0x21, 0xcc, 0xba, 0x6d, 0x8f, 0xd8, 0x30,
12430	0xe8, 0xb2, 0xaa, 0x11, 0xbb, 0x6f, 0x53, 0xd2, 0x2d, 0x8f, 0xf3, 0x6d, 0xf7, 0x7a, 0x3f, 0x70,
12431	0x22, 0x17, 0x4e, 0x91, 0x46, 0x5d, 0xa8, 0xb8, 0x21, 0x83, 0x9d, 0x27, 0x2f, 0x66, 0xdd, 0xb3,
12432	0x5b, 0x8a, 0xe6, 0xbc, 0x03, 0x4c, 0x70, 0x05, 0x2f, 0x1f, 0x1d, 0x56, 0x2a, 0x4b, 0x4f, 0x67,
12433	0xc5, 0x83, 0xb0, 0xd0, 0xfb, 0x50, 0x56, 0xd2, 0xf4, 0x4c, 0x72, 0x3d, 0x2f, 0xb2, 0x38, 0x94,
12434	0xaa, 0x20, 0x55, 0x1a, 0x51, 0x98, 0x54, 0xc2, 0x0d, 0xa8, 0x76, 0x79, 0x2a, 0xd3, 0x45, 0x64,
12435	0xa4, 0x6f, 0xd5, 0xbf, 0x8c, 0x88, 0x10, 0x6c, 0x1c, 0xd3, 0x80, 0xfe, 0x06, 0x90, 0x12, 0xed,
12436	0x99, 0xb5, 0xcb, 0x28, 0x53, 0xfa, 0x89, 0x35, 0xdb, 0xfa, 0x6e, 0x17, 0x23, 0xd9, 0x38, 0x41,
12437	0x0f, 0x5a, 0x85, 0x19, 0x31, 0xba, 0xa5, 0xdb, 0xca, 0x0e, 0x69, 0xf6, 0xed, 0x16, 0xd5, 0xec,
12438	0xf2, 0x34, 0x8f, 0x7d, 0xfc, 0xe1, 0x6b, 0x21, 0x81, 0x8e, 0x13, 0xa5, 0xd0, 0x3b, 0x30, 0xb9,
12439	0x63, 0x58, 0xdb, 0x6a, 0xbb, 0x4d, 0x74, 0x17, 0x69, 0x86, 0x23, 0xcd, 0xb0, 0xd5, 0x58, 0x8e,
12440	0xd0, 0x70, 0x8c, 0x1b, 0xd9, 0x70, 0x4e, 0x20, 0x37, 0x2c, 0xa3, 0xb5, 0x66, 0xf4, 0x74, 0xea,
12441	0x94, 0x44, 0xe7, 0xbc, 0x14, 0x73, 0x6e, 0x21, 0x89, 0xe1, 0xc9, 0x61, 0xe5, 0x52, 0x72, 0x05,
12442	0xec, 0x33, 0xe1, 0x64, 0x6c, 0xb4, 0x0b, 0xc0, 0xe3, 0x82, 0x73, 0xfc, 0x66, 0xf9, 0xf1, 0xbb,
12443	0x93, 0x25, 0xea, 0x24, 0x9e, 0x40, 0xe7, 0x49, 0xce, 0x23, 0xe3, 0x00, 0x36, 0xfb, 0x4a, 0x51,
12444	0x22, 0x6d, 0xd5, 0x76, 0x79, 0x8e, 0xef, 0x75, 0x2d, 0xdb, 0x5e, 0x7b, 0x72, 0x81, 0xa7, 0xa9,
12445	0x28, 0x22, 0x8e, 0x2b, 0xe1, 0x5d, 0x3a, 0xe2, 0xcd, 0xe6, 0x74, 0x3a, 0x9d, 0x8f, 0xd7, 0xa5,
12446	0xe3, 0x9b, 0xf6, 0xcc, 0xba, 0x74, 0x02, 0x90, 0x4f, 0xbf, 0x25, 0xfe, 0x55, 0x0e, 0xa6, 0x7d,
12447	0xe6, 0xcc, 0x5d, 0x3a, 0x09, 0x22, 0x7f, 0xec, 0x76, 0x1e, 0xdc, 0xed, 0xfc, 0xa5, 0x04, 0xe3,
12448	0xfe, 0xd2, 0xfd, 0xfe, 0x75, 0xce, 0xf8, 0xb6, 0xa5, 0xd4, 0xf2, 0xff, 0x9b, 0x0b, 0x4e, 0xe0,
12449	0x0f, 0xbe, 0x7d, 0xe3, 0x87, 0xb7, 0x28, 0xcb, 0x5f, 0xe7, 0x61, 0x32, 0x7a, 0x1a, 0x43, 0xaf,
12450	0xfc, 0xd2, 0xc0, 0x57, 0xfe, 0x06, 0xcc, 0xec, 0xf4, 0x34, 0xad, 0xcf, 0x97, 0x21, 0xf0, 0xd4,
12451	0xef, 0xbc, 0xd2, 0xbd, 0x28, 0x24, 0x67, 0x96, 0x13, 0x78, 0x70, 0xa2, 0x64, 0x4a, 0xc7, 0x42,
12452	0xfe, 0x44, 0x1d, 0x0b, 0xb1, 0x07, 0xf4, 0xc2, 0x31, 0x1e, 0xd0, 0x13, 0xbb, 0x0f, 0x86, 0x4e,
12453	0xd0, 0x7d, 0x70, 0x92, 0x76, 0x81, 0x84, 0x20, 0x36, 0xb0, 0x7b, 0xf5, 0x45, 0x38, 0x2f, 0xc4,
12454	0x28, 0x7f, 0xc9, 0xd7, 0xa9, 0x65, 0x68, 0x1a, 0xb1, 0x96, 0x7a, 0xdd, 0x6e, 0x5f, 0x7e, 0x0b,
12455	0xc6, 0xc3, 0x3d, 0x2a, 0xce, 0x4e, 0x3b, 0x6d, 0x32, 0xe2, 0xad, 0x34, 0xb0, 0xd3, 0xce, 0x38,
12456	0xf6, 0x38, 0xe4, 0xbf, 0x97, 0x60, 0x36, 0xb9, 0x17, 0x15, 0x69, 0x30, 0xde, 0x55, 0x0e, 0x82,
12457	0xfd, 0xc1, 0xd2, 0x09, 0x6f, 0xb1, 0x78, 0x73, 0xc2, 0x5a, 0x08, 0x0b, 0x47, 0xb0, 0xe5, 0xef,
12458	0x25, 0x98, 0x4b, 0x69, 0x0b, 0x38, 0x5d, 0x4b, 0xd0, 0x07, 0x50, 0xea, 0x2a, 0x07, 0xcd, 0x9e,
12459	0xd5, 0x21, 0x27, 0xbe, 0xb7, 0xe3, 0x11, 0x63, 0x4d, 0xa0, 0x60, 0x0f, 0x4f, 0xfe, 0x4f, 0x09,
12460	0x5e, 0x48, 0xad, 0x65, 0xd0, 0xed, 0x50, 0x07, 0x83, 0x1c, 0xe9, 0x60, 0x40, 0x71, 0xc1, 0xe7,
12461	0xd4, 0xc0, 0xf0, 0xb9, 0x04, 0xe5, 0xb4, 0xef, 0x3c, 0x74, 0x2b, 0x64, 0xe4, 0x4b, 0x11, 0x23,
12462	0xa7, 0x62, 0x72, 0xcf, 0xc9, 0xc6, 0xff, 0x91, 0x60, 0x36, 0xf9, 0x7b, 0x17, 0xbd, 0x1e, 0xb2,
12463	0xb0, 0x12, 0xb1, 0x70, 0x22, 0x22, 0x25, 0xec, 0xfb, 0x08, 0xc6, 0xc5, 0x57, 0xb1, 0x80, 0x11,
12464	0x7b, 0x2f, 0x27, 0x45, 0x74, 0x01, 0xe1, 0xd6, 0xa0, 0xdc, 0xab, 0xc2, 0x63, 0x38, 0x82, 0x26,
12465	0xff, 0x43, 0x0e, 0x86, 0x9a, 0x2d, 0x45, 0x23, 0xa7, 0x50, 0x0c, 0xbe, 0x1b, 0x2a, 0x06, 0x07,
12466	0xfd, 0xc7, 0x11, 0xb7, 0x2a, 0xb5, 0x0e, 0xc4, 0x91, 0x3a, 0xf0, 0xd5, 0x4c, 0x68, 0x4f, 0x2f,
12467	0x01, 0xff, 0x0c, 0x46, 0x3c, 0xa5, 0xc7, 0xcb, 0x4c, 0xf2, 0x7f, 0xe4, 0x60, 0x34, 0xa0, 0xe2,
12468	0x98, 0x79, 0x6d, 0x27, 0x54, 0x0f, 0xe4, 0x33, 0x7c, 0x78, 0x04, 0x74, 0x55, 0xdd, 0x0a, 0xc0,
12469	0xe9, 0x98, 0xf5, 0x7b, 0x24, 0xe3, 0x85, 0xc1, 0x5b, 0x30, 0x4e, 0x15, 0xab, 0x43, 0xa8, 0x77,
12470	0x27, 0x9f, 0xe7, 0xbe, 0xe8, 0xf5, 0x59, 0x6f, 0x86, 0xa8, 0x38, 0xc2, 0x7d, 0xfe, 0x2e, 0x8c,
12471	0x85, 0x94, 0x1d, 0xab, 0xe1, 0xf5, 0xff, 0x25, 0x78, 0x69, 0xe0, 0x8d, 0x09, 0xaa, 0x87, 0x0e,
12472	0x49, 0x35, 0x72, 0x48, 0xe6, 0xd3, 0x01, 0x9e, 0x5f, 0xe3, 0x54, 0xfd, 0xda, 0xe3, 0xef, 0xe6,
12473	0xcf, 0x7c, 0xf3, 0xdd, 0xfc, 0x99, 0x6f, 0xbf, 0x9b, 0x3f, 0xf3, 0xb7, 0x47, 0xf3, 0xd2, 0xe3,
12474	0xa3, 0x79, 0xe9, 0x9b, 0xa3, 0x79, 0xe9, 0xdb, 0xa3, 0x79, 0xe9, 0x17, 0x47, 0xf3, 0xd2, 0xbf,
12475	0x7c, 0x3f, 0x7f, 0xe6, 0x83, 0xa2, 0x80, 0xfb, 0x5d, 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0xf0,
12476	0x40, 0xcd, 0xc4, 0x3c, 0x00, 0x00,
12477}
12478