blob: 5b29f432080b905a862c701e296681fb47813533 [file] [log] [blame]
sslobodr60a6d0f2019-01-18 14:51:05 -05001/*
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/apps/v1/generated.proto
19
20/*
21 Package v1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/apps/v1/generated.proto
25
26 It has these top-level messages:
27 ControllerRevision
28 ControllerRevisionList
29 DaemonSet
30 DaemonSetCondition
31 DaemonSetList
32 DaemonSetSpec
33 DaemonSetStatus
34 DaemonSetUpdateStrategy
35 Deployment
36 DeploymentCondition
37 DeploymentList
38 DeploymentSpec
39 DeploymentStatus
40 DeploymentStrategy
41 ReplicaSet
42 ReplicaSetCondition
43 ReplicaSetList
44 ReplicaSetSpec
45 ReplicaSetStatus
46 RollingUpdateDaemonSet
47 RollingUpdateDeployment
48 RollingUpdateStatefulSetStrategy
49 StatefulSet
50 StatefulSetCondition
51 StatefulSetList
52 StatefulSetSpec
53 StatefulSetStatus
54 StatefulSetUpdateStrategy
55*/
56package v1
57
58import proto "github.com/gogo/protobuf/proto"
59import fmt "fmt"
60import math "math"
61
62import k8s_io_api_core_v1 "k8s.io/api/core/v1"
63import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
64
65import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr"
66
67import strings "strings"
68import reflect "reflect"
69
70import io "io"
71
72// Reference imports to suppress errors if they are not otherwise used.
73var _ = proto.Marshal
74var _ = fmt.Errorf
75var _ = math.Inf
76
77// This is a compile-time assertion to ensure that this generated file
78// is compatible with the proto package it is being compiled against.
79// A compilation error at this line likely means your copy of the
80// proto package needs to be updated.
81const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
82
83func (m *ControllerRevision) Reset() { *m = ControllerRevision{} }
84func (*ControllerRevision) ProtoMessage() {}
85func (*ControllerRevision) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
86
87func (m *ControllerRevisionList) Reset() { *m = ControllerRevisionList{} }
88func (*ControllerRevisionList) ProtoMessage() {}
89func (*ControllerRevisionList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
90
91func (m *DaemonSet) Reset() { *m = DaemonSet{} }
92func (*DaemonSet) ProtoMessage() {}
93func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
94
95func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} }
96func (*DaemonSetCondition) ProtoMessage() {}
97func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
98
99func (m *DaemonSetList) Reset() { *m = DaemonSetList{} }
100func (*DaemonSetList) ProtoMessage() {}
101func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
102
103func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} }
104func (*DaemonSetSpec) ProtoMessage() {}
105func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
106
107func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} }
108func (*DaemonSetStatus) ProtoMessage() {}
109func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
110
111func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} }
112func (*DaemonSetUpdateStrategy) ProtoMessage() {}
113func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
114
115func (m *Deployment) Reset() { *m = Deployment{} }
116func (*Deployment) ProtoMessage() {}
117func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
118
119func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} }
120func (*DeploymentCondition) ProtoMessage() {}
121func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
122
123func (m *DeploymentList) Reset() { *m = DeploymentList{} }
124func (*DeploymentList) ProtoMessage() {}
125func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
126
127func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} }
128func (*DeploymentSpec) ProtoMessage() {}
129func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
130
131func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} }
132func (*DeploymentStatus) ProtoMessage() {}
133func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
134
135func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} }
136func (*DeploymentStrategy) ProtoMessage() {}
137func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
138
139func (m *ReplicaSet) Reset() { *m = ReplicaSet{} }
140func (*ReplicaSet) ProtoMessage() {}
141func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
142
143func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} }
144func (*ReplicaSetCondition) ProtoMessage() {}
145func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
146
147func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} }
148func (*ReplicaSetList) ProtoMessage() {}
149func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
150
151func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} }
152func (*ReplicaSetSpec) ProtoMessage() {}
153func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
154
155func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} }
156func (*ReplicaSetStatus) ProtoMessage() {}
157func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
158
159func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} }
160func (*RollingUpdateDaemonSet) ProtoMessage() {}
161func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
162
163func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
164func (*RollingUpdateDeployment) ProtoMessage() {}
165func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
166 return fileDescriptorGenerated, []int{20}
167}
168
169func (m *RollingUpdateStatefulSetStrategy) Reset() { *m = RollingUpdateStatefulSetStrategy{} }
170func (*RollingUpdateStatefulSetStrategy) ProtoMessage() {}
171func (*RollingUpdateStatefulSetStrategy) Descriptor() ([]byte, []int) {
172 return fileDescriptorGenerated, []int{21}
173}
174
175func (m *StatefulSet) Reset() { *m = StatefulSet{} }
176func (*StatefulSet) ProtoMessage() {}
177func (*StatefulSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
178
179func (m *StatefulSetCondition) Reset() { *m = StatefulSetCondition{} }
180func (*StatefulSetCondition) ProtoMessage() {}
181func (*StatefulSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
182
183func (m *StatefulSetList) Reset() { *m = StatefulSetList{} }
184func (*StatefulSetList) ProtoMessage() {}
185func (*StatefulSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
186
187func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} }
188func (*StatefulSetSpec) ProtoMessage() {}
189func (*StatefulSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
190
191func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} }
192func (*StatefulSetStatus) ProtoMessage() {}
193func (*StatefulSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
194
195func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} }
196func (*StatefulSetUpdateStrategy) ProtoMessage() {}
197func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) {
198 return fileDescriptorGenerated, []int{27}
199}
200
201func init() {
202 proto.RegisterType((*ControllerRevision)(nil), "k8s.io.api.apps.v1.ControllerRevision")
203 proto.RegisterType((*ControllerRevisionList)(nil), "k8s.io.api.apps.v1.ControllerRevisionList")
204 proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.apps.v1.DaemonSet")
205 proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.apps.v1.DaemonSetCondition")
206 proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.apps.v1.DaemonSetList")
207 proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.apps.v1.DaemonSetSpec")
208 proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.apps.v1.DaemonSetStatus")
209 proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.apps.v1.DaemonSetUpdateStrategy")
210 proto.RegisterType((*Deployment)(nil), "k8s.io.api.apps.v1.Deployment")
211 proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.apps.v1.DeploymentCondition")
212 proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.apps.v1.DeploymentList")
213 proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.apps.v1.DeploymentSpec")
214 proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.apps.v1.DeploymentStatus")
215 proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.apps.v1.DeploymentStrategy")
216 proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.apps.v1.ReplicaSet")
217 proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.apps.v1.ReplicaSetCondition")
218 proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.apps.v1.ReplicaSetList")
219 proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.apps.v1.ReplicaSetSpec")
220 proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.apps.v1.ReplicaSetStatus")
221 proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.apps.v1.RollingUpdateDaemonSet")
222 proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.apps.v1.RollingUpdateDeployment")
223 proto.RegisterType((*RollingUpdateStatefulSetStrategy)(nil), "k8s.io.api.apps.v1.RollingUpdateStatefulSetStrategy")
224 proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1.StatefulSet")
225 proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1.StatefulSetCondition")
226 proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1.StatefulSetList")
227 proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1.StatefulSetSpec")
228 proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1.StatefulSetStatus")
229 proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1.StatefulSetUpdateStrategy")
230}
231func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
232 size := m.Size()
233 dAtA = make([]byte, size)
234 n, err := m.MarshalTo(dAtA)
235 if err != nil {
236 return nil, err
237 }
238 return dAtA[:n], nil
239}
240
241func (m *ControllerRevision) MarshalTo(dAtA []byte) (int, error) {
242 var i int
243 _ = i
244 var l int
245 _ = l
246 dAtA[i] = 0xa
247 i++
248 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
249 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
250 if err != nil {
251 return 0, err
252 }
253 i += n1
254 dAtA[i] = 0x12
255 i++
256 i = encodeVarintGenerated(dAtA, i, uint64(m.Data.Size()))
257 n2, err := m.Data.MarshalTo(dAtA[i:])
258 if err != nil {
259 return 0, err
260 }
261 i += n2
262 dAtA[i] = 0x18
263 i++
264 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
265 return i, nil
266}
267
268func (m *ControllerRevisionList) Marshal() (dAtA []byte, err error) {
269 size := m.Size()
270 dAtA = make([]byte, size)
271 n, err := m.MarshalTo(dAtA)
272 if err != nil {
273 return nil, err
274 }
275 return dAtA[:n], nil
276}
277
278func (m *ControllerRevisionList) MarshalTo(dAtA []byte) (int, error) {
279 var i int
280 _ = i
281 var l int
282 _ = l
283 dAtA[i] = 0xa
284 i++
285 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
286 n3, err := m.ListMeta.MarshalTo(dAtA[i:])
287 if err != nil {
288 return 0, err
289 }
290 i += n3
291 if len(m.Items) > 0 {
292 for _, msg := range m.Items {
293 dAtA[i] = 0x12
294 i++
295 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
296 n, err := msg.MarshalTo(dAtA[i:])
297 if err != nil {
298 return 0, err
299 }
300 i += n
301 }
302 }
303 return i, nil
304}
305
306func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
307 size := m.Size()
308 dAtA = make([]byte, size)
309 n, err := m.MarshalTo(dAtA)
310 if err != nil {
311 return nil, err
312 }
313 return dAtA[:n], nil
314}
315
316func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
317 var i int
318 _ = i
319 var l int
320 _ = l
321 dAtA[i] = 0xa
322 i++
323 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
324 n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
325 if err != nil {
326 return 0, err
327 }
328 i += n4
329 dAtA[i] = 0x12
330 i++
331 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
332 n5, err := m.Spec.MarshalTo(dAtA[i:])
333 if err != nil {
334 return 0, err
335 }
336 i += n5
337 dAtA[i] = 0x1a
338 i++
339 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
340 n6, err := m.Status.MarshalTo(dAtA[i:])
341 if err != nil {
342 return 0, err
343 }
344 i += n6
345 return i, nil
346}
347
348func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
349 size := m.Size()
350 dAtA = make([]byte, size)
351 n, err := m.MarshalTo(dAtA)
352 if err != nil {
353 return nil, err
354 }
355 return dAtA[:n], nil
356}
357
358func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
359 var i int
360 _ = i
361 var l int
362 _ = l
363 dAtA[i] = 0xa
364 i++
365 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
366 i += copy(dAtA[i:], m.Type)
367 dAtA[i] = 0x12
368 i++
369 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
370 i += copy(dAtA[i:], m.Status)
371 dAtA[i] = 0x1a
372 i++
373 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
374 n7, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
375 if err != nil {
376 return 0, err
377 }
378 i += n7
379 dAtA[i] = 0x22
380 i++
381 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
382 i += copy(dAtA[i:], m.Reason)
383 dAtA[i] = 0x2a
384 i++
385 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
386 i += copy(dAtA[i:], m.Message)
387 return i, nil
388}
389
390func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
391 size := m.Size()
392 dAtA = make([]byte, size)
393 n, err := m.MarshalTo(dAtA)
394 if err != nil {
395 return nil, err
396 }
397 return dAtA[:n], nil
398}
399
400func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
401 var i int
402 _ = i
403 var l int
404 _ = l
405 dAtA[i] = 0xa
406 i++
407 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
408 n8, err := m.ListMeta.MarshalTo(dAtA[i:])
409 if err != nil {
410 return 0, err
411 }
412 i += n8
413 if len(m.Items) > 0 {
414 for _, msg := range m.Items {
415 dAtA[i] = 0x12
416 i++
417 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
418 n, err := msg.MarshalTo(dAtA[i:])
419 if err != nil {
420 return 0, err
421 }
422 i += n
423 }
424 }
425 return i, nil
426}
427
428func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
429 size := m.Size()
430 dAtA = make([]byte, size)
431 n, err := m.MarshalTo(dAtA)
432 if err != nil {
433 return nil, err
434 }
435 return dAtA[:n], nil
436}
437
438func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
439 var i int
440 _ = i
441 var l int
442 _ = l
443 if m.Selector != nil {
444 dAtA[i] = 0xa
445 i++
446 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
447 n9, err := m.Selector.MarshalTo(dAtA[i:])
448 if err != nil {
449 return 0, err
450 }
451 i += n9
452 }
453 dAtA[i] = 0x12
454 i++
455 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
456 n10, err := m.Template.MarshalTo(dAtA[i:])
457 if err != nil {
458 return 0, err
459 }
460 i += n10
461 dAtA[i] = 0x1a
462 i++
463 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
464 n11, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
465 if err != nil {
466 return 0, err
467 }
468 i += n11
469 dAtA[i] = 0x20
470 i++
471 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
472 if m.RevisionHistoryLimit != nil {
473 dAtA[i] = 0x30
474 i++
475 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
476 }
477 return i, nil
478}
479
480func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
481 size := m.Size()
482 dAtA = make([]byte, size)
483 n, err := m.MarshalTo(dAtA)
484 if err != nil {
485 return nil, err
486 }
487 return dAtA[:n], nil
488}
489
490func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
491 var i int
492 _ = i
493 var l int
494 _ = l
495 dAtA[i] = 0x8
496 i++
497 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
498 dAtA[i] = 0x10
499 i++
500 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
501 dAtA[i] = 0x18
502 i++
503 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
504 dAtA[i] = 0x20
505 i++
506 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
507 dAtA[i] = 0x28
508 i++
509 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
510 dAtA[i] = 0x30
511 i++
512 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
513 dAtA[i] = 0x38
514 i++
515 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
516 dAtA[i] = 0x40
517 i++
518 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
519 if m.CollisionCount != nil {
520 dAtA[i] = 0x48
521 i++
522 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
523 }
524 if len(m.Conditions) > 0 {
525 for _, msg := range m.Conditions {
526 dAtA[i] = 0x52
527 i++
528 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
529 n, err := msg.MarshalTo(dAtA[i:])
530 if err != nil {
531 return 0, err
532 }
533 i += n
534 }
535 }
536 return i, nil
537}
538
539func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
540 size := m.Size()
541 dAtA = make([]byte, size)
542 n, err := m.MarshalTo(dAtA)
543 if err != nil {
544 return nil, err
545 }
546 return dAtA[:n], nil
547}
548
549func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
550 var i int
551 _ = i
552 var l int
553 _ = l
554 dAtA[i] = 0xa
555 i++
556 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
557 i += copy(dAtA[i:], m.Type)
558 if m.RollingUpdate != nil {
559 dAtA[i] = 0x12
560 i++
561 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
562 n12, err := m.RollingUpdate.MarshalTo(dAtA[i:])
563 if err != nil {
564 return 0, err
565 }
566 i += n12
567 }
568 return i, nil
569}
570
571func (m *Deployment) Marshal() (dAtA []byte, err error) {
572 size := m.Size()
573 dAtA = make([]byte, size)
574 n, err := m.MarshalTo(dAtA)
575 if err != nil {
576 return nil, err
577 }
578 return dAtA[:n], nil
579}
580
581func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
582 var i int
583 _ = i
584 var l int
585 _ = l
586 dAtA[i] = 0xa
587 i++
588 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
589 n13, err := m.ObjectMeta.MarshalTo(dAtA[i:])
590 if err != nil {
591 return 0, err
592 }
593 i += n13
594 dAtA[i] = 0x12
595 i++
596 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
597 n14, err := m.Spec.MarshalTo(dAtA[i:])
598 if err != nil {
599 return 0, err
600 }
601 i += n14
602 dAtA[i] = 0x1a
603 i++
604 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
605 n15, err := m.Status.MarshalTo(dAtA[i:])
606 if err != nil {
607 return 0, err
608 }
609 i += n15
610 return i, nil
611}
612
613func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
614 size := m.Size()
615 dAtA = make([]byte, size)
616 n, err := m.MarshalTo(dAtA)
617 if err != nil {
618 return nil, err
619 }
620 return dAtA[:n], nil
621}
622
623func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
624 var i int
625 _ = i
626 var l int
627 _ = l
628 dAtA[i] = 0xa
629 i++
630 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
631 i += copy(dAtA[i:], m.Type)
632 dAtA[i] = 0x12
633 i++
634 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
635 i += copy(dAtA[i:], m.Status)
636 dAtA[i] = 0x22
637 i++
638 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
639 i += copy(dAtA[i:], m.Reason)
640 dAtA[i] = 0x2a
641 i++
642 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
643 i += copy(dAtA[i:], m.Message)
644 dAtA[i] = 0x32
645 i++
646 i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size()))
647 n16, err := m.LastUpdateTime.MarshalTo(dAtA[i:])
648 if err != nil {
649 return 0, err
650 }
651 i += n16
652 dAtA[i] = 0x3a
653 i++
654 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
655 n17, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
656 if err != nil {
657 return 0, err
658 }
659 i += n17
660 return i, nil
661}
662
663func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
664 size := m.Size()
665 dAtA = make([]byte, size)
666 n, err := m.MarshalTo(dAtA)
667 if err != nil {
668 return nil, err
669 }
670 return dAtA[:n], nil
671}
672
673func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
674 var i int
675 _ = i
676 var l int
677 _ = l
678 dAtA[i] = 0xa
679 i++
680 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
681 n18, err := m.ListMeta.MarshalTo(dAtA[i:])
682 if err != nil {
683 return 0, err
684 }
685 i += n18
686 if len(m.Items) > 0 {
687 for _, msg := range m.Items {
688 dAtA[i] = 0x12
689 i++
690 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
691 n, err := msg.MarshalTo(dAtA[i:])
692 if err != nil {
693 return 0, err
694 }
695 i += n
696 }
697 }
698 return i, nil
699}
700
701func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
702 size := m.Size()
703 dAtA = make([]byte, size)
704 n, err := m.MarshalTo(dAtA)
705 if err != nil {
706 return nil, err
707 }
708 return dAtA[:n], nil
709}
710
711func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
712 var i int
713 _ = i
714 var l int
715 _ = l
716 if m.Replicas != nil {
717 dAtA[i] = 0x8
718 i++
719 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
720 }
721 if m.Selector != nil {
722 dAtA[i] = 0x12
723 i++
724 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
725 n19, err := m.Selector.MarshalTo(dAtA[i:])
726 if err != nil {
727 return 0, err
728 }
729 i += n19
730 }
731 dAtA[i] = 0x1a
732 i++
733 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
734 n20, err := m.Template.MarshalTo(dAtA[i:])
735 if err != nil {
736 return 0, err
737 }
738 i += n20
739 dAtA[i] = 0x22
740 i++
741 i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size()))
742 n21, err := m.Strategy.MarshalTo(dAtA[i:])
743 if err != nil {
744 return 0, err
745 }
746 i += n21
747 dAtA[i] = 0x28
748 i++
749 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
750 if m.RevisionHistoryLimit != nil {
751 dAtA[i] = 0x30
752 i++
753 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
754 }
755 dAtA[i] = 0x38
756 i++
757 if m.Paused {
758 dAtA[i] = 1
759 } else {
760 dAtA[i] = 0
761 }
762 i++
763 if m.ProgressDeadlineSeconds != nil {
764 dAtA[i] = 0x48
765 i++
766 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
767 }
768 return i, nil
769}
770
771func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
772 size := m.Size()
773 dAtA = make([]byte, size)
774 n, err := m.MarshalTo(dAtA)
775 if err != nil {
776 return nil, err
777 }
778 return dAtA[:n], nil
779}
780
781func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
782 var i int
783 _ = i
784 var l int
785 _ = l
786 dAtA[i] = 0x8
787 i++
788 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
789 dAtA[i] = 0x10
790 i++
791 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
792 dAtA[i] = 0x18
793 i++
794 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
795 dAtA[i] = 0x20
796 i++
797 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
798 dAtA[i] = 0x28
799 i++
800 i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
801 if len(m.Conditions) > 0 {
802 for _, msg := range m.Conditions {
803 dAtA[i] = 0x32
804 i++
805 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
806 n, err := msg.MarshalTo(dAtA[i:])
807 if err != nil {
808 return 0, err
809 }
810 i += n
811 }
812 }
813 dAtA[i] = 0x38
814 i++
815 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
816 if m.CollisionCount != nil {
817 dAtA[i] = 0x40
818 i++
819 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
820 }
821 return i, nil
822}
823
824func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
825 size := m.Size()
826 dAtA = make([]byte, size)
827 n, err := m.MarshalTo(dAtA)
828 if err != nil {
829 return nil, err
830 }
831 return dAtA[:n], nil
832}
833
834func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
835 var i int
836 _ = i
837 var l int
838 _ = l
839 dAtA[i] = 0xa
840 i++
841 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
842 i += copy(dAtA[i:], m.Type)
843 if m.RollingUpdate != nil {
844 dAtA[i] = 0x12
845 i++
846 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
847 n22, err := m.RollingUpdate.MarshalTo(dAtA[i:])
848 if err != nil {
849 return 0, err
850 }
851 i += n22
852 }
853 return i, nil
854}
855
856func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
857 size := m.Size()
858 dAtA = make([]byte, size)
859 n, err := m.MarshalTo(dAtA)
860 if err != nil {
861 return nil, err
862 }
863 return dAtA[:n], nil
864}
865
866func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
867 var i int
868 _ = i
869 var l int
870 _ = l
871 dAtA[i] = 0xa
872 i++
873 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
874 n23, err := m.ObjectMeta.MarshalTo(dAtA[i:])
875 if err != nil {
876 return 0, err
877 }
878 i += n23
879 dAtA[i] = 0x12
880 i++
881 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
882 n24, err := m.Spec.MarshalTo(dAtA[i:])
883 if err != nil {
884 return 0, err
885 }
886 i += n24
887 dAtA[i] = 0x1a
888 i++
889 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
890 n25, err := m.Status.MarshalTo(dAtA[i:])
891 if err != nil {
892 return 0, err
893 }
894 i += n25
895 return i, nil
896}
897
898func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
899 size := m.Size()
900 dAtA = make([]byte, size)
901 n, err := m.MarshalTo(dAtA)
902 if err != nil {
903 return nil, err
904 }
905 return dAtA[:n], nil
906}
907
908func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
909 var i int
910 _ = i
911 var l int
912 _ = l
913 dAtA[i] = 0xa
914 i++
915 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
916 i += copy(dAtA[i:], m.Type)
917 dAtA[i] = 0x12
918 i++
919 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
920 i += copy(dAtA[i:], m.Status)
921 dAtA[i] = 0x1a
922 i++
923 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
924 n26, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
925 if err != nil {
926 return 0, err
927 }
928 i += n26
929 dAtA[i] = 0x22
930 i++
931 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
932 i += copy(dAtA[i:], m.Reason)
933 dAtA[i] = 0x2a
934 i++
935 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
936 i += copy(dAtA[i:], m.Message)
937 return i, nil
938}
939
940func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
941 size := m.Size()
942 dAtA = make([]byte, size)
943 n, err := m.MarshalTo(dAtA)
944 if err != nil {
945 return nil, err
946 }
947 return dAtA[:n], nil
948}
949
950func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
951 var i int
952 _ = i
953 var l int
954 _ = l
955 dAtA[i] = 0xa
956 i++
957 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
958 n27, err := m.ListMeta.MarshalTo(dAtA[i:])
959 if err != nil {
960 return 0, err
961 }
962 i += n27
963 if len(m.Items) > 0 {
964 for _, msg := range m.Items {
965 dAtA[i] = 0x12
966 i++
967 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
968 n, err := msg.MarshalTo(dAtA[i:])
969 if err != nil {
970 return 0, err
971 }
972 i += n
973 }
974 }
975 return i, nil
976}
977
978func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
979 size := m.Size()
980 dAtA = make([]byte, size)
981 n, err := m.MarshalTo(dAtA)
982 if err != nil {
983 return nil, err
984 }
985 return dAtA[:n], nil
986}
987
988func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
989 var i int
990 _ = i
991 var l int
992 _ = l
993 if m.Replicas != nil {
994 dAtA[i] = 0x8
995 i++
996 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
997 }
998 if m.Selector != nil {
999 dAtA[i] = 0x12
1000 i++
1001 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
1002 n28, err := m.Selector.MarshalTo(dAtA[i:])
1003 if err != nil {
1004 return 0, err
1005 }
1006 i += n28
1007 }
1008 dAtA[i] = 0x1a
1009 i++
1010 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
1011 n29, err := m.Template.MarshalTo(dAtA[i:])
1012 if err != nil {
1013 return 0, err
1014 }
1015 i += n29
1016 dAtA[i] = 0x20
1017 i++
1018 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
1019 return i, nil
1020}
1021
1022func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
1023 size := m.Size()
1024 dAtA = make([]byte, size)
1025 n, err := m.MarshalTo(dAtA)
1026 if err != nil {
1027 return nil, err
1028 }
1029 return dAtA[:n], nil
1030}
1031
1032func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
1033 var i int
1034 _ = i
1035 var l int
1036 _ = l
1037 dAtA[i] = 0x8
1038 i++
1039 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1040 dAtA[i] = 0x10
1041 i++
1042 i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
1043 dAtA[i] = 0x18
1044 i++
1045 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1046 dAtA[i] = 0x20
1047 i++
1048 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1049 dAtA[i] = 0x28
1050 i++
1051 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1052 if len(m.Conditions) > 0 {
1053 for _, msg := range m.Conditions {
1054 dAtA[i] = 0x32
1055 i++
1056 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1057 n, err := msg.MarshalTo(dAtA[i:])
1058 if err != nil {
1059 return 0, err
1060 }
1061 i += n
1062 }
1063 }
1064 return i, nil
1065}
1066
1067func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
1068 size := m.Size()
1069 dAtA = make([]byte, size)
1070 n, err := m.MarshalTo(dAtA)
1071 if err != nil {
1072 return nil, err
1073 }
1074 return dAtA[:n], nil
1075}
1076
1077func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
1078 var i int
1079 _ = i
1080 var l int
1081 _ = l
1082 if m.MaxUnavailable != nil {
1083 dAtA[i] = 0xa
1084 i++
1085 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
1086 n30, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
1087 if err != nil {
1088 return 0, err
1089 }
1090 i += n30
1091 }
1092 return i, nil
1093}
1094
1095func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
1096 size := m.Size()
1097 dAtA = make([]byte, size)
1098 n, err := m.MarshalTo(dAtA)
1099 if err != nil {
1100 return nil, err
1101 }
1102 return dAtA[:n], nil
1103}
1104
1105func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
1106 var i int
1107 _ = i
1108 var l int
1109 _ = l
1110 if m.MaxUnavailable != nil {
1111 dAtA[i] = 0xa
1112 i++
1113 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size()))
1114 n31, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
1115 if err != nil {
1116 return 0, err
1117 }
1118 i += n31
1119 }
1120 if m.MaxSurge != nil {
1121 dAtA[i] = 0x12
1122 i++
1123 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
1124 n32, err := m.MaxSurge.MarshalTo(dAtA[i:])
1125 if err != nil {
1126 return 0, err
1127 }
1128 i += n32
1129 }
1130 return i, nil
1131}
1132
1133func (m *RollingUpdateStatefulSetStrategy) Marshal() (dAtA []byte, err error) {
1134 size := m.Size()
1135 dAtA = make([]byte, size)
1136 n, err := m.MarshalTo(dAtA)
1137 if err != nil {
1138 return nil, err
1139 }
1140 return dAtA[:n], nil
1141}
1142
1143func (m *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
1144 var i int
1145 _ = i
1146 var l int
1147 _ = l
1148 if m.Partition != nil {
1149 dAtA[i] = 0x8
1150 i++
1151 i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition))
1152 }
1153 return i, nil
1154}
1155
1156func (m *StatefulSet) Marshal() (dAtA []byte, err error) {
1157 size := m.Size()
1158 dAtA = make([]byte, size)
1159 n, err := m.MarshalTo(dAtA)
1160 if err != nil {
1161 return nil, err
1162 }
1163 return dAtA[:n], nil
1164}
1165
1166func (m *StatefulSet) MarshalTo(dAtA []byte) (int, error) {
1167 var i int
1168 _ = i
1169 var l int
1170 _ = l
1171 dAtA[i] = 0xa
1172 i++
1173 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
1174 n33, err := m.ObjectMeta.MarshalTo(dAtA[i:])
1175 if err != nil {
1176 return 0, err
1177 }
1178 i += n33
1179 dAtA[i] = 0x12
1180 i++
1181 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
1182 n34, err := m.Spec.MarshalTo(dAtA[i:])
1183 if err != nil {
1184 return 0, err
1185 }
1186 i += n34
1187 dAtA[i] = 0x1a
1188 i++
1189 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
1190 n35, err := m.Status.MarshalTo(dAtA[i:])
1191 if err != nil {
1192 return 0, err
1193 }
1194 i += n35
1195 return i, nil
1196}
1197
1198func (m *StatefulSetCondition) Marshal() (dAtA []byte, err error) {
1199 size := m.Size()
1200 dAtA = make([]byte, size)
1201 n, err := m.MarshalTo(dAtA)
1202 if err != nil {
1203 return nil, err
1204 }
1205 return dAtA[:n], nil
1206}
1207
1208func (m *StatefulSetCondition) MarshalTo(dAtA []byte) (int, error) {
1209 var i int
1210 _ = i
1211 var l int
1212 _ = l
1213 dAtA[i] = 0xa
1214 i++
1215 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1216 i += copy(dAtA[i:], m.Type)
1217 dAtA[i] = 0x12
1218 i++
1219 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1220 i += copy(dAtA[i:], m.Status)
1221 dAtA[i] = 0x1a
1222 i++
1223 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
1224 n36, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
1225 if err != nil {
1226 return 0, err
1227 }
1228 i += n36
1229 dAtA[i] = 0x22
1230 i++
1231 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1232 i += copy(dAtA[i:], m.Reason)
1233 dAtA[i] = 0x2a
1234 i++
1235 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1236 i += copy(dAtA[i:], m.Message)
1237 return i, nil
1238}
1239
1240func (m *StatefulSetList) 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 *StatefulSetList) 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(m.ListMeta.Size()))
1258 n37, err := m.ListMeta.MarshalTo(dAtA[i:])
1259 if err != nil {
1260 return 0, err
1261 }
1262 i += n37
1263 if len(m.Items) > 0 {
1264 for _, msg := range m.Items {
1265 dAtA[i] = 0x12
1266 i++
1267 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1268 n, err := msg.MarshalTo(dAtA[i:])
1269 if err != nil {
1270 return 0, err
1271 }
1272 i += n
1273 }
1274 }
1275 return i, nil
1276}
1277
1278func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) {
1279 size := m.Size()
1280 dAtA = make([]byte, size)
1281 n, err := m.MarshalTo(dAtA)
1282 if err != nil {
1283 return nil, err
1284 }
1285 return dAtA[:n], nil
1286}
1287
1288func (m *StatefulSetSpec) MarshalTo(dAtA []byte) (int, error) {
1289 var i int
1290 _ = i
1291 var l int
1292 _ = l
1293 if m.Replicas != nil {
1294 dAtA[i] = 0x8
1295 i++
1296 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
1297 }
1298 if m.Selector != nil {
1299 dAtA[i] = 0x12
1300 i++
1301 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
1302 n38, err := m.Selector.MarshalTo(dAtA[i:])
1303 if err != nil {
1304 return 0, err
1305 }
1306 i += n38
1307 }
1308 dAtA[i] = 0x1a
1309 i++
1310 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
1311 n39, err := m.Template.MarshalTo(dAtA[i:])
1312 if err != nil {
1313 return 0, err
1314 }
1315 i += n39
1316 if len(m.VolumeClaimTemplates) > 0 {
1317 for _, msg := range m.VolumeClaimTemplates {
1318 dAtA[i] = 0x22
1319 i++
1320 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1321 n, err := msg.MarshalTo(dAtA[i:])
1322 if err != nil {
1323 return 0, err
1324 }
1325 i += n
1326 }
1327 }
1328 dAtA[i] = 0x2a
1329 i++
1330 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
1331 i += copy(dAtA[i:], m.ServiceName)
1332 dAtA[i] = 0x32
1333 i++
1334 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodManagementPolicy)))
1335 i += copy(dAtA[i:], m.PodManagementPolicy)
1336 dAtA[i] = 0x3a
1337 i++
1338 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size()))
1339 n40, err := m.UpdateStrategy.MarshalTo(dAtA[i:])
1340 if err != nil {
1341 return 0, err
1342 }
1343 i += n40
1344 if m.RevisionHistoryLimit != nil {
1345 dAtA[i] = 0x40
1346 i++
1347 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
1348 }
1349 return i, nil
1350}
1351
1352func (m *StatefulSetStatus) Marshal() (dAtA []byte, err error) {
1353 size := m.Size()
1354 dAtA = make([]byte, size)
1355 n, err := m.MarshalTo(dAtA)
1356 if err != nil {
1357 return nil, err
1358 }
1359 return dAtA[:n], nil
1360}
1361
1362func (m *StatefulSetStatus) MarshalTo(dAtA []byte) (int, error) {
1363 var i int
1364 _ = i
1365 var l int
1366 _ = l
1367 dAtA[i] = 0x8
1368 i++
1369 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1370 dAtA[i] = 0x10
1371 i++
1372 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1373 dAtA[i] = 0x18
1374 i++
1375 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1376 dAtA[i] = 0x20
1377 i++
1378 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas))
1379 dAtA[i] = 0x28
1380 i++
1381 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1382 dAtA[i] = 0x32
1383 i++
1384 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentRevision)))
1385 i += copy(dAtA[i:], m.CurrentRevision)
1386 dAtA[i] = 0x3a
1387 i++
1388 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UpdateRevision)))
1389 i += copy(dAtA[i:], m.UpdateRevision)
1390 if m.CollisionCount != nil {
1391 dAtA[i] = 0x48
1392 i++
1393 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1394 }
1395 if len(m.Conditions) > 0 {
1396 for _, msg := range m.Conditions {
1397 dAtA[i] = 0x52
1398 i++
1399 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1400 n, err := msg.MarshalTo(dAtA[i:])
1401 if err != nil {
1402 return 0, err
1403 }
1404 i += n
1405 }
1406 }
1407 return i, nil
1408}
1409
1410func (m *StatefulSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
1411 size := m.Size()
1412 dAtA = make([]byte, size)
1413 n, err := m.MarshalTo(dAtA)
1414 if err != nil {
1415 return nil, err
1416 }
1417 return dAtA[:n], nil
1418}
1419
1420func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
1421 var i int
1422 _ = i
1423 var l int
1424 _ = l
1425 dAtA[i] = 0xa
1426 i++
1427 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1428 i += copy(dAtA[i:], m.Type)
1429 if m.RollingUpdate != nil {
1430 dAtA[i] = 0x12
1431 i++
1432 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
1433 n41, err := m.RollingUpdate.MarshalTo(dAtA[i:])
1434 if err != nil {
1435 return 0, err
1436 }
1437 i += n41
1438 }
1439 return i, nil
1440}
1441
1442func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1443 for v >= 1<<7 {
1444 dAtA[offset] = uint8(v&0x7f | 0x80)
1445 v >>= 7
1446 offset++
1447 }
1448 dAtA[offset] = uint8(v)
1449 return offset + 1
1450}
1451func (m *ControllerRevision) Size() (n int) {
1452 var l int
1453 _ = l
1454 l = m.ObjectMeta.Size()
1455 n += 1 + l + sovGenerated(uint64(l))
1456 l = m.Data.Size()
1457 n += 1 + l + sovGenerated(uint64(l))
1458 n += 1 + sovGenerated(uint64(m.Revision))
1459 return n
1460}
1461
1462func (m *ControllerRevisionList) Size() (n int) {
1463 var l int
1464 _ = l
1465 l = m.ListMeta.Size()
1466 n += 1 + l + sovGenerated(uint64(l))
1467 if len(m.Items) > 0 {
1468 for _, e := range m.Items {
1469 l = e.Size()
1470 n += 1 + l + sovGenerated(uint64(l))
1471 }
1472 }
1473 return n
1474}
1475
1476func (m *DaemonSet) Size() (n int) {
1477 var l int
1478 _ = l
1479 l = m.ObjectMeta.Size()
1480 n += 1 + l + sovGenerated(uint64(l))
1481 l = m.Spec.Size()
1482 n += 1 + l + sovGenerated(uint64(l))
1483 l = m.Status.Size()
1484 n += 1 + l + sovGenerated(uint64(l))
1485 return n
1486}
1487
1488func (m *DaemonSetCondition) Size() (n int) {
1489 var l int
1490 _ = l
1491 l = len(m.Type)
1492 n += 1 + l + sovGenerated(uint64(l))
1493 l = len(m.Status)
1494 n += 1 + l + sovGenerated(uint64(l))
1495 l = m.LastTransitionTime.Size()
1496 n += 1 + l + sovGenerated(uint64(l))
1497 l = len(m.Reason)
1498 n += 1 + l + sovGenerated(uint64(l))
1499 l = len(m.Message)
1500 n += 1 + l + sovGenerated(uint64(l))
1501 return n
1502}
1503
1504func (m *DaemonSetList) Size() (n int) {
1505 var l int
1506 _ = l
1507 l = m.ListMeta.Size()
1508 n += 1 + l + sovGenerated(uint64(l))
1509 if len(m.Items) > 0 {
1510 for _, e := range m.Items {
1511 l = e.Size()
1512 n += 1 + l + sovGenerated(uint64(l))
1513 }
1514 }
1515 return n
1516}
1517
1518func (m *DaemonSetSpec) Size() (n int) {
1519 var l int
1520 _ = l
1521 if m.Selector != nil {
1522 l = m.Selector.Size()
1523 n += 1 + l + sovGenerated(uint64(l))
1524 }
1525 l = m.Template.Size()
1526 n += 1 + l + sovGenerated(uint64(l))
1527 l = m.UpdateStrategy.Size()
1528 n += 1 + l + sovGenerated(uint64(l))
1529 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
1530 if m.RevisionHistoryLimit != nil {
1531 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
1532 }
1533 return n
1534}
1535
1536func (m *DaemonSetStatus) Size() (n int) {
1537 var l int
1538 _ = l
1539 n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
1540 n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
1541 n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
1542 n += 1 + sovGenerated(uint64(m.NumberReady))
1543 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1544 n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
1545 n += 1 + sovGenerated(uint64(m.NumberAvailable))
1546 n += 1 + sovGenerated(uint64(m.NumberUnavailable))
1547 if m.CollisionCount != nil {
1548 n += 1 + sovGenerated(uint64(*m.CollisionCount))
1549 }
1550 if len(m.Conditions) > 0 {
1551 for _, e := range m.Conditions {
1552 l = e.Size()
1553 n += 1 + l + sovGenerated(uint64(l))
1554 }
1555 }
1556 return n
1557}
1558
1559func (m *DaemonSetUpdateStrategy) Size() (n int) {
1560 var l int
1561 _ = l
1562 l = len(m.Type)
1563 n += 1 + l + sovGenerated(uint64(l))
1564 if m.RollingUpdate != nil {
1565 l = m.RollingUpdate.Size()
1566 n += 1 + l + sovGenerated(uint64(l))
1567 }
1568 return n
1569}
1570
1571func (m *Deployment) Size() (n int) {
1572 var l int
1573 _ = l
1574 l = m.ObjectMeta.Size()
1575 n += 1 + l + sovGenerated(uint64(l))
1576 l = m.Spec.Size()
1577 n += 1 + l + sovGenerated(uint64(l))
1578 l = m.Status.Size()
1579 n += 1 + l + sovGenerated(uint64(l))
1580 return n
1581}
1582
1583func (m *DeploymentCondition) Size() (n int) {
1584 var l int
1585 _ = l
1586 l = len(m.Type)
1587 n += 1 + l + sovGenerated(uint64(l))
1588 l = len(m.Status)
1589 n += 1 + l + sovGenerated(uint64(l))
1590 l = len(m.Reason)
1591 n += 1 + l + sovGenerated(uint64(l))
1592 l = len(m.Message)
1593 n += 1 + l + sovGenerated(uint64(l))
1594 l = m.LastUpdateTime.Size()
1595 n += 1 + l + sovGenerated(uint64(l))
1596 l = m.LastTransitionTime.Size()
1597 n += 1 + l + sovGenerated(uint64(l))
1598 return n
1599}
1600
1601func (m *DeploymentList) Size() (n int) {
1602 var l int
1603 _ = l
1604 l = m.ListMeta.Size()
1605 n += 1 + l + sovGenerated(uint64(l))
1606 if len(m.Items) > 0 {
1607 for _, e := range m.Items {
1608 l = e.Size()
1609 n += 1 + l + sovGenerated(uint64(l))
1610 }
1611 }
1612 return n
1613}
1614
1615func (m *DeploymentSpec) Size() (n int) {
1616 var l int
1617 _ = l
1618 if m.Replicas != nil {
1619 n += 1 + sovGenerated(uint64(*m.Replicas))
1620 }
1621 if m.Selector != nil {
1622 l = m.Selector.Size()
1623 n += 1 + l + sovGenerated(uint64(l))
1624 }
1625 l = m.Template.Size()
1626 n += 1 + l + sovGenerated(uint64(l))
1627 l = m.Strategy.Size()
1628 n += 1 + l + sovGenerated(uint64(l))
1629 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
1630 if m.RevisionHistoryLimit != nil {
1631 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
1632 }
1633 n += 2
1634 if m.ProgressDeadlineSeconds != nil {
1635 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
1636 }
1637 return n
1638}
1639
1640func (m *DeploymentStatus) Size() (n int) {
1641 var l int
1642 _ = l
1643 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1644 n += 1 + sovGenerated(uint64(m.Replicas))
1645 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
1646 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
1647 n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
1648 if len(m.Conditions) > 0 {
1649 for _, e := range m.Conditions {
1650 l = e.Size()
1651 n += 1 + l + sovGenerated(uint64(l))
1652 }
1653 }
1654 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
1655 if m.CollisionCount != nil {
1656 n += 1 + sovGenerated(uint64(*m.CollisionCount))
1657 }
1658 return n
1659}
1660
1661func (m *DeploymentStrategy) Size() (n int) {
1662 var l int
1663 _ = l
1664 l = len(m.Type)
1665 n += 1 + l + sovGenerated(uint64(l))
1666 if m.RollingUpdate != nil {
1667 l = m.RollingUpdate.Size()
1668 n += 1 + l + sovGenerated(uint64(l))
1669 }
1670 return n
1671}
1672
1673func (m *ReplicaSet) Size() (n int) {
1674 var l int
1675 _ = l
1676 l = m.ObjectMeta.Size()
1677 n += 1 + l + sovGenerated(uint64(l))
1678 l = m.Spec.Size()
1679 n += 1 + l + sovGenerated(uint64(l))
1680 l = m.Status.Size()
1681 n += 1 + l + sovGenerated(uint64(l))
1682 return n
1683}
1684
1685func (m *ReplicaSetCondition) Size() (n int) {
1686 var l int
1687 _ = l
1688 l = len(m.Type)
1689 n += 1 + l + sovGenerated(uint64(l))
1690 l = len(m.Status)
1691 n += 1 + l + sovGenerated(uint64(l))
1692 l = m.LastTransitionTime.Size()
1693 n += 1 + l + sovGenerated(uint64(l))
1694 l = len(m.Reason)
1695 n += 1 + l + sovGenerated(uint64(l))
1696 l = len(m.Message)
1697 n += 1 + l + sovGenerated(uint64(l))
1698 return n
1699}
1700
1701func (m *ReplicaSetList) Size() (n int) {
1702 var l int
1703 _ = l
1704 l = m.ListMeta.Size()
1705 n += 1 + l + sovGenerated(uint64(l))
1706 if len(m.Items) > 0 {
1707 for _, e := range m.Items {
1708 l = e.Size()
1709 n += 1 + l + sovGenerated(uint64(l))
1710 }
1711 }
1712 return n
1713}
1714
1715func (m *ReplicaSetSpec) Size() (n int) {
1716 var l int
1717 _ = l
1718 if m.Replicas != nil {
1719 n += 1 + sovGenerated(uint64(*m.Replicas))
1720 }
1721 if m.Selector != nil {
1722 l = m.Selector.Size()
1723 n += 1 + l + sovGenerated(uint64(l))
1724 }
1725 l = m.Template.Size()
1726 n += 1 + l + sovGenerated(uint64(l))
1727 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
1728 return n
1729}
1730
1731func (m *ReplicaSetStatus) Size() (n int) {
1732 var l int
1733 _ = l
1734 n += 1 + sovGenerated(uint64(m.Replicas))
1735 n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
1736 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1737 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
1738 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
1739 if len(m.Conditions) > 0 {
1740 for _, e := range m.Conditions {
1741 l = e.Size()
1742 n += 1 + l + sovGenerated(uint64(l))
1743 }
1744 }
1745 return n
1746}
1747
1748func (m *RollingUpdateDaemonSet) Size() (n int) {
1749 var l int
1750 _ = l
1751 if m.MaxUnavailable != nil {
1752 l = m.MaxUnavailable.Size()
1753 n += 1 + l + sovGenerated(uint64(l))
1754 }
1755 return n
1756}
1757
1758func (m *RollingUpdateDeployment) Size() (n int) {
1759 var l int
1760 _ = l
1761 if m.MaxUnavailable != nil {
1762 l = m.MaxUnavailable.Size()
1763 n += 1 + l + sovGenerated(uint64(l))
1764 }
1765 if m.MaxSurge != nil {
1766 l = m.MaxSurge.Size()
1767 n += 1 + l + sovGenerated(uint64(l))
1768 }
1769 return n
1770}
1771
1772func (m *RollingUpdateStatefulSetStrategy) Size() (n int) {
1773 var l int
1774 _ = l
1775 if m.Partition != nil {
1776 n += 1 + sovGenerated(uint64(*m.Partition))
1777 }
1778 return n
1779}
1780
1781func (m *StatefulSet) Size() (n int) {
1782 var l int
1783 _ = l
1784 l = m.ObjectMeta.Size()
1785 n += 1 + l + sovGenerated(uint64(l))
1786 l = m.Spec.Size()
1787 n += 1 + l + sovGenerated(uint64(l))
1788 l = m.Status.Size()
1789 n += 1 + l + sovGenerated(uint64(l))
1790 return n
1791}
1792
1793func (m *StatefulSetCondition) Size() (n int) {
1794 var l int
1795 _ = l
1796 l = len(m.Type)
1797 n += 1 + l + sovGenerated(uint64(l))
1798 l = len(m.Status)
1799 n += 1 + l + sovGenerated(uint64(l))
1800 l = m.LastTransitionTime.Size()
1801 n += 1 + l + sovGenerated(uint64(l))
1802 l = len(m.Reason)
1803 n += 1 + l + sovGenerated(uint64(l))
1804 l = len(m.Message)
1805 n += 1 + l + sovGenerated(uint64(l))
1806 return n
1807}
1808
1809func (m *StatefulSetList) Size() (n int) {
1810 var l int
1811 _ = l
1812 l = m.ListMeta.Size()
1813 n += 1 + l + sovGenerated(uint64(l))
1814 if len(m.Items) > 0 {
1815 for _, e := range m.Items {
1816 l = e.Size()
1817 n += 1 + l + sovGenerated(uint64(l))
1818 }
1819 }
1820 return n
1821}
1822
1823func (m *StatefulSetSpec) Size() (n int) {
1824 var l int
1825 _ = l
1826 if m.Replicas != nil {
1827 n += 1 + sovGenerated(uint64(*m.Replicas))
1828 }
1829 if m.Selector != nil {
1830 l = m.Selector.Size()
1831 n += 1 + l + sovGenerated(uint64(l))
1832 }
1833 l = m.Template.Size()
1834 n += 1 + l + sovGenerated(uint64(l))
1835 if len(m.VolumeClaimTemplates) > 0 {
1836 for _, e := range m.VolumeClaimTemplates {
1837 l = e.Size()
1838 n += 1 + l + sovGenerated(uint64(l))
1839 }
1840 }
1841 l = len(m.ServiceName)
1842 n += 1 + l + sovGenerated(uint64(l))
1843 l = len(m.PodManagementPolicy)
1844 n += 1 + l + sovGenerated(uint64(l))
1845 l = m.UpdateStrategy.Size()
1846 n += 1 + l + sovGenerated(uint64(l))
1847 if m.RevisionHistoryLimit != nil {
1848 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
1849 }
1850 return n
1851}
1852
1853func (m *StatefulSetStatus) Size() (n int) {
1854 var l int
1855 _ = l
1856 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
1857 n += 1 + sovGenerated(uint64(m.Replicas))
1858 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
1859 n += 1 + sovGenerated(uint64(m.CurrentReplicas))
1860 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
1861 l = len(m.CurrentRevision)
1862 n += 1 + l + sovGenerated(uint64(l))
1863 l = len(m.UpdateRevision)
1864 n += 1 + l + sovGenerated(uint64(l))
1865 if m.CollisionCount != nil {
1866 n += 1 + sovGenerated(uint64(*m.CollisionCount))
1867 }
1868 if len(m.Conditions) > 0 {
1869 for _, e := range m.Conditions {
1870 l = e.Size()
1871 n += 1 + l + sovGenerated(uint64(l))
1872 }
1873 }
1874 return n
1875}
1876
1877func (m *StatefulSetUpdateStrategy) Size() (n int) {
1878 var l int
1879 _ = l
1880 l = len(m.Type)
1881 n += 1 + l + sovGenerated(uint64(l))
1882 if m.RollingUpdate != nil {
1883 l = m.RollingUpdate.Size()
1884 n += 1 + l + sovGenerated(uint64(l))
1885 }
1886 return n
1887}
1888
1889func sovGenerated(x uint64) (n int) {
1890 for {
1891 n++
1892 x >>= 7
1893 if x == 0 {
1894 break
1895 }
1896 }
1897 return n
1898}
1899func sozGenerated(x uint64) (n int) {
1900 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1901}
1902func (this *ControllerRevision) String() string {
1903 if this == nil {
1904 return "nil"
1905 }
1906 s := strings.Join([]string{`&ControllerRevision{`,
1907 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1908 `Data:` + strings.Replace(strings.Replace(this.Data.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
1909 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
1910 `}`,
1911 }, "")
1912 return s
1913}
1914func (this *ControllerRevisionList) String() string {
1915 if this == nil {
1916 return "nil"
1917 }
1918 s := strings.Join([]string{`&ControllerRevisionList{`,
1919 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1920 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ControllerRevision", "ControllerRevision", 1), `&`, ``, 1) + `,`,
1921 `}`,
1922 }, "")
1923 return s
1924}
1925func (this *DaemonSet) String() string {
1926 if this == nil {
1927 return "nil"
1928 }
1929 s := strings.Join([]string{`&DaemonSet{`,
1930 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1931 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
1932 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
1933 `}`,
1934 }, "")
1935 return s
1936}
1937func (this *DaemonSetCondition) String() string {
1938 if this == nil {
1939 return "nil"
1940 }
1941 s := strings.Join([]string{`&DaemonSetCondition{`,
1942 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1943 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
1944 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
1945 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
1946 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
1947 `}`,
1948 }, "")
1949 return s
1950}
1951func (this *DaemonSetList) String() string {
1952 if this == nil {
1953 return "nil"
1954 }
1955 s := strings.Join([]string{`&DaemonSetList{`,
1956 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1957 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`,
1958 `}`,
1959 }, "")
1960 return s
1961}
1962func (this *DaemonSetSpec) String() string {
1963 if this == nil {
1964 return "nil"
1965 }
1966 s := strings.Join([]string{`&DaemonSetSpec{`,
1967 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1968 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
1969 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
1970 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
1971 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
1972 `}`,
1973 }, "")
1974 return s
1975}
1976func (this *DaemonSetStatus) String() string {
1977 if this == nil {
1978 return "nil"
1979 }
1980 s := strings.Join([]string{`&DaemonSetStatus{`,
1981 `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
1982 `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
1983 `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
1984 `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
1985 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
1986 `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
1987 `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
1988 `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
1989 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
1990 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`,
1991 `}`,
1992 }, "")
1993 return s
1994}
1995func (this *DaemonSetUpdateStrategy) String() string {
1996 if this == nil {
1997 return "nil"
1998 }
1999 s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
2000 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2001 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
2002 `}`,
2003 }, "")
2004 return s
2005}
2006func (this *Deployment) String() string {
2007 if this == nil {
2008 return "nil"
2009 }
2010 s := strings.Join([]string{`&Deployment{`,
2011 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2012 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
2013 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
2014 `}`,
2015 }, "")
2016 return s
2017}
2018func (this *DeploymentCondition) String() string {
2019 if this == nil {
2020 return "nil"
2021 }
2022 s := strings.Join([]string{`&DeploymentCondition{`,
2023 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2024 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2025 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2026 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2027 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
2028 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
2029 `}`,
2030 }, "")
2031 return s
2032}
2033func (this *DeploymentList) String() string {
2034 if this == nil {
2035 return "nil"
2036 }
2037 s := strings.Join([]string{`&DeploymentList{`,
2038 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
2039 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`,
2040 `}`,
2041 }, "")
2042 return s
2043}
2044func (this *DeploymentSpec) String() string {
2045 if this == nil {
2046 return "nil"
2047 }
2048 s := strings.Join([]string{`&DeploymentSpec{`,
2049 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
2050 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
2051 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2052 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
2053 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
2054 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
2055 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
2056 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
2057 `}`,
2058 }, "")
2059 return s
2060}
2061func (this *DeploymentStatus) String() string {
2062 if this == nil {
2063 return "nil"
2064 }
2065 s := strings.Join([]string{`&DeploymentStatus{`,
2066 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
2067 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2068 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
2069 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
2070 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
2071 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`,
2072 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
2073 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
2074 `}`,
2075 }, "")
2076 return s
2077}
2078func (this *DeploymentStrategy) String() string {
2079 if this == nil {
2080 return "nil"
2081 }
2082 s := strings.Join([]string{`&DeploymentStrategy{`,
2083 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2084 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
2085 `}`,
2086 }, "")
2087 return s
2088}
2089func (this *ReplicaSet) String() string {
2090 if this == nil {
2091 return "nil"
2092 }
2093 s := strings.Join([]string{`&ReplicaSet{`,
2094 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2095 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
2096 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
2097 `}`,
2098 }, "")
2099 return s
2100}
2101func (this *ReplicaSetCondition) String() string {
2102 if this == nil {
2103 return "nil"
2104 }
2105 s := strings.Join([]string{`&ReplicaSetCondition{`,
2106 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2107 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2108 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
2109 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2110 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2111 `}`,
2112 }, "")
2113 return s
2114}
2115func (this *ReplicaSetList) String() string {
2116 if this == nil {
2117 return "nil"
2118 }
2119 s := strings.Join([]string{`&ReplicaSetList{`,
2120 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
2121 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`,
2122 `}`,
2123 }, "")
2124 return s
2125}
2126func (this *ReplicaSetSpec) String() string {
2127 if this == nil {
2128 return "nil"
2129 }
2130 s := strings.Join([]string{`&ReplicaSetSpec{`,
2131 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
2132 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
2133 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2134 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
2135 `}`,
2136 }, "")
2137 return s
2138}
2139func (this *ReplicaSetStatus) String() string {
2140 if this == nil {
2141 return "nil"
2142 }
2143 s := strings.Join([]string{`&ReplicaSetStatus{`,
2144 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2145 `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
2146 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
2147 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
2148 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
2149 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`,
2150 `}`,
2151 }, "")
2152 return s
2153}
2154func (this *RollingUpdateDaemonSet) String() string {
2155 if this == nil {
2156 return "nil"
2157 }
2158 s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
2159 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
2160 `}`,
2161 }, "")
2162 return s
2163}
2164func (this *RollingUpdateDeployment) String() string {
2165 if this == nil {
2166 return "nil"
2167 }
2168 s := strings.Join([]string{`&RollingUpdateDeployment{`,
2169 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
2170 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`,
2171 `}`,
2172 }, "")
2173 return s
2174}
2175func (this *RollingUpdateStatefulSetStrategy) String() string {
2176 if this == nil {
2177 return "nil"
2178 }
2179 s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`,
2180 `Partition:` + valueToStringGenerated(this.Partition) + `,`,
2181 `}`,
2182 }, "")
2183 return s
2184}
2185func (this *StatefulSet) String() string {
2186 if this == nil {
2187 return "nil"
2188 }
2189 s := strings.Join([]string{`&StatefulSet{`,
2190 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2191 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StatefulSetSpec", "StatefulSetSpec", 1), `&`, ``, 1) + `,`,
2192 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "StatefulSetStatus", "StatefulSetStatus", 1), `&`, ``, 1) + `,`,
2193 `}`,
2194 }, "")
2195 return s
2196}
2197func (this *StatefulSetCondition) String() string {
2198 if this == nil {
2199 return "nil"
2200 }
2201 s := strings.Join([]string{`&StatefulSetCondition{`,
2202 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2203 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2204 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
2205 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2206 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2207 `}`,
2208 }, "")
2209 return s
2210}
2211func (this *StatefulSetList) String() string {
2212 if this == nil {
2213 return "nil"
2214 }
2215 s := strings.Join([]string{`&StatefulSetList{`,
2216 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
2217 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "StatefulSet", "StatefulSet", 1), `&`, ``, 1) + `,`,
2218 `}`,
2219 }, "")
2220 return s
2221}
2222func (this *StatefulSetSpec) String() string {
2223 if this == nil {
2224 return "nil"
2225 }
2226 s := strings.Join([]string{`&StatefulSetSpec{`,
2227 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
2228 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
2229 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2230 `VolumeClaimTemplates:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.VolumeClaimTemplates), "PersistentVolumeClaim", "k8s_io_api_core_v1.PersistentVolumeClaim", 1), `&`, ``, 1) + `,`,
2231 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
2232 `PodManagementPolicy:` + fmt.Sprintf("%v", this.PodManagementPolicy) + `,`,
2233 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
2234 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
2235 `}`,
2236 }, "")
2237 return s
2238}
2239func (this *StatefulSetStatus) String() string {
2240 if this == nil {
2241 return "nil"
2242 }
2243 s := strings.Join([]string{`&StatefulSetStatus{`,
2244 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
2245 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2246 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
2247 `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`,
2248 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
2249 `CurrentRevision:` + fmt.Sprintf("%v", this.CurrentRevision) + `,`,
2250 `UpdateRevision:` + fmt.Sprintf("%v", this.UpdateRevision) + `,`,
2251 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
2252 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "StatefulSetCondition", "StatefulSetCondition", 1), `&`, ``, 1) + `,`,
2253 `}`,
2254 }, "")
2255 return s
2256}
2257func (this *StatefulSetUpdateStrategy) String() string {
2258 if this == nil {
2259 return "nil"
2260 }
2261 s := strings.Join([]string{`&StatefulSetUpdateStrategy{`,
2262 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2263 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 1) + `,`,
2264 `}`,
2265 }, "")
2266 return s
2267}
2268func valueToStringGenerated(v interface{}) string {
2269 rv := reflect.ValueOf(v)
2270 if rv.IsNil() {
2271 return "nil"
2272 }
2273 pv := reflect.Indirect(rv).Interface()
2274 return fmt.Sprintf("*%v", pv)
2275}
2276func (m *ControllerRevision) Unmarshal(dAtA []byte) error {
2277 l := len(dAtA)
2278 iNdEx := 0
2279 for iNdEx < l {
2280 preIndex := iNdEx
2281 var wire uint64
2282 for shift := uint(0); ; shift += 7 {
2283 if shift >= 64 {
2284 return ErrIntOverflowGenerated
2285 }
2286 if iNdEx >= l {
2287 return io.ErrUnexpectedEOF
2288 }
2289 b := dAtA[iNdEx]
2290 iNdEx++
2291 wire |= (uint64(b) & 0x7F) << shift
2292 if b < 0x80 {
2293 break
2294 }
2295 }
2296 fieldNum := int32(wire >> 3)
2297 wireType := int(wire & 0x7)
2298 if wireType == 4 {
2299 return fmt.Errorf("proto: ControllerRevision: wiretype end group for non-group")
2300 }
2301 if fieldNum <= 0 {
2302 return fmt.Errorf("proto: ControllerRevision: illegal tag %d (wire type %d)", fieldNum, wire)
2303 }
2304 switch fieldNum {
2305 case 1:
2306 if wireType != 2 {
2307 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2308 }
2309 var msglen int
2310 for shift := uint(0); ; shift += 7 {
2311 if shift >= 64 {
2312 return ErrIntOverflowGenerated
2313 }
2314 if iNdEx >= l {
2315 return io.ErrUnexpectedEOF
2316 }
2317 b := dAtA[iNdEx]
2318 iNdEx++
2319 msglen |= (int(b) & 0x7F) << shift
2320 if b < 0x80 {
2321 break
2322 }
2323 }
2324 if msglen < 0 {
2325 return ErrInvalidLengthGenerated
2326 }
2327 postIndex := iNdEx + msglen
2328 if postIndex > l {
2329 return io.ErrUnexpectedEOF
2330 }
2331 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2332 return err
2333 }
2334 iNdEx = postIndex
2335 case 2:
2336 if wireType != 2 {
2337 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
2338 }
2339 var msglen int
2340 for shift := uint(0); ; shift += 7 {
2341 if shift >= 64 {
2342 return ErrIntOverflowGenerated
2343 }
2344 if iNdEx >= l {
2345 return io.ErrUnexpectedEOF
2346 }
2347 b := dAtA[iNdEx]
2348 iNdEx++
2349 msglen |= (int(b) & 0x7F) << shift
2350 if b < 0x80 {
2351 break
2352 }
2353 }
2354 if msglen < 0 {
2355 return ErrInvalidLengthGenerated
2356 }
2357 postIndex := iNdEx + msglen
2358 if postIndex > l {
2359 return io.ErrUnexpectedEOF
2360 }
2361 if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2362 return err
2363 }
2364 iNdEx = postIndex
2365 case 3:
2366 if wireType != 0 {
2367 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
2368 }
2369 m.Revision = 0
2370 for shift := uint(0); ; shift += 7 {
2371 if shift >= 64 {
2372 return ErrIntOverflowGenerated
2373 }
2374 if iNdEx >= l {
2375 return io.ErrUnexpectedEOF
2376 }
2377 b := dAtA[iNdEx]
2378 iNdEx++
2379 m.Revision |= (int64(b) & 0x7F) << shift
2380 if b < 0x80 {
2381 break
2382 }
2383 }
2384 default:
2385 iNdEx = preIndex
2386 skippy, err := skipGenerated(dAtA[iNdEx:])
2387 if err != nil {
2388 return err
2389 }
2390 if skippy < 0 {
2391 return ErrInvalidLengthGenerated
2392 }
2393 if (iNdEx + skippy) > l {
2394 return io.ErrUnexpectedEOF
2395 }
2396 iNdEx += skippy
2397 }
2398 }
2399
2400 if iNdEx > l {
2401 return io.ErrUnexpectedEOF
2402 }
2403 return nil
2404}
2405func (m *ControllerRevisionList) Unmarshal(dAtA []byte) error {
2406 l := len(dAtA)
2407 iNdEx := 0
2408 for iNdEx < l {
2409 preIndex := iNdEx
2410 var wire uint64
2411 for shift := uint(0); ; shift += 7 {
2412 if shift >= 64 {
2413 return ErrIntOverflowGenerated
2414 }
2415 if iNdEx >= l {
2416 return io.ErrUnexpectedEOF
2417 }
2418 b := dAtA[iNdEx]
2419 iNdEx++
2420 wire |= (uint64(b) & 0x7F) << shift
2421 if b < 0x80 {
2422 break
2423 }
2424 }
2425 fieldNum := int32(wire >> 3)
2426 wireType := int(wire & 0x7)
2427 if wireType == 4 {
2428 return fmt.Errorf("proto: ControllerRevisionList: wiretype end group for non-group")
2429 }
2430 if fieldNum <= 0 {
2431 return fmt.Errorf("proto: ControllerRevisionList: illegal tag %d (wire type %d)", fieldNum, wire)
2432 }
2433 switch fieldNum {
2434 case 1:
2435 if wireType != 2 {
2436 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2437 }
2438 var msglen int
2439 for shift := uint(0); ; shift += 7 {
2440 if shift >= 64 {
2441 return ErrIntOverflowGenerated
2442 }
2443 if iNdEx >= l {
2444 return io.ErrUnexpectedEOF
2445 }
2446 b := dAtA[iNdEx]
2447 iNdEx++
2448 msglen |= (int(b) & 0x7F) << shift
2449 if b < 0x80 {
2450 break
2451 }
2452 }
2453 if msglen < 0 {
2454 return ErrInvalidLengthGenerated
2455 }
2456 postIndex := iNdEx + msglen
2457 if postIndex > l {
2458 return io.ErrUnexpectedEOF
2459 }
2460 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2461 return err
2462 }
2463 iNdEx = postIndex
2464 case 2:
2465 if wireType != 2 {
2466 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2467 }
2468 var msglen int
2469 for shift := uint(0); ; shift += 7 {
2470 if shift >= 64 {
2471 return ErrIntOverflowGenerated
2472 }
2473 if iNdEx >= l {
2474 return io.ErrUnexpectedEOF
2475 }
2476 b := dAtA[iNdEx]
2477 iNdEx++
2478 msglen |= (int(b) & 0x7F) << shift
2479 if b < 0x80 {
2480 break
2481 }
2482 }
2483 if msglen < 0 {
2484 return ErrInvalidLengthGenerated
2485 }
2486 postIndex := iNdEx + msglen
2487 if postIndex > l {
2488 return io.ErrUnexpectedEOF
2489 }
2490 m.Items = append(m.Items, ControllerRevision{})
2491 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2492 return err
2493 }
2494 iNdEx = postIndex
2495 default:
2496 iNdEx = preIndex
2497 skippy, err := skipGenerated(dAtA[iNdEx:])
2498 if err != nil {
2499 return err
2500 }
2501 if skippy < 0 {
2502 return ErrInvalidLengthGenerated
2503 }
2504 if (iNdEx + skippy) > l {
2505 return io.ErrUnexpectedEOF
2506 }
2507 iNdEx += skippy
2508 }
2509 }
2510
2511 if iNdEx > l {
2512 return io.ErrUnexpectedEOF
2513 }
2514 return nil
2515}
2516func (m *DaemonSet) Unmarshal(dAtA []byte) error {
2517 l := len(dAtA)
2518 iNdEx := 0
2519 for iNdEx < l {
2520 preIndex := iNdEx
2521 var wire uint64
2522 for shift := uint(0); ; shift += 7 {
2523 if shift >= 64 {
2524 return ErrIntOverflowGenerated
2525 }
2526 if iNdEx >= l {
2527 return io.ErrUnexpectedEOF
2528 }
2529 b := dAtA[iNdEx]
2530 iNdEx++
2531 wire |= (uint64(b) & 0x7F) << shift
2532 if b < 0x80 {
2533 break
2534 }
2535 }
2536 fieldNum := int32(wire >> 3)
2537 wireType := int(wire & 0x7)
2538 if wireType == 4 {
2539 return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
2540 }
2541 if fieldNum <= 0 {
2542 return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
2543 }
2544 switch fieldNum {
2545 case 1:
2546 if wireType != 2 {
2547 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2548 }
2549 var msglen int
2550 for shift := uint(0); ; shift += 7 {
2551 if shift >= 64 {
2552 return ErrIntOverflowGenerated
2553 }
2554 if iNdEx >= l {
2555 return io.ErrUnexpectedEOF
2556 }
2557 b := dAtA[iNdEx]
2558 iNdEx++
2559 msglen |= (int(b) & 0x7F) << shift
2560 if b < 0x80 {
2561 break
2562 }
2563 }
2564 if msglen < 0 {
2565 return ErrInvalidLengthGenerated
2566 }
2567 postIndex := iNdEx + msglen
2568 if postIndex > l {
2569 return io.ErrUnexpectedEOF
2570 }
2571 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2572 return err
2573 }
2574 iNdEx = postIndex
2575 case 2:
2576 if wireType != 2 {
2577 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2578 }
2579 var msglen int
2580 for shift := uint(0); ; shift += 7 {
2581 if shift >= 64 {
2582 return ErrIntOverflowGenerated
2583 }
2584 if iNdEx >= l {
2585 return io.ErrUnexpectedEOF
2586 }
2587 b := dAtA[iNdEx]
2588 iNdEx++
2589 msglen |= (int(b) & 0x7F) << shift
2590 if b < 0x80 {
2591 break
2592 }
2593 }
2594 if msglen < 0 {
2595 return ErrInvalidLengthGenerated
2596 }
2597 postIndex := iNdEx + msglen
2598 if postIndex > l {
2599 return io.ErrUnexpectedEOF
2600 }
2601 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2602 return err
2603 }
2604 iNdEx = postIndex
2605 case 3:
2606 if wireType != 2 {
2607 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2608 }
2609 var msglen int
2610 for shift := uint(0); ; shift += 7 {
2611 if shift >= 64 {
2612 return ErrIntOverflowGenerated
2613 }
2614 if iNdEx >= l {
2615 return io.ErrUnexpectedEOF
2616 }
2617 b := dAtA[iNdEx]
2618 iNdEx++
2619 msglen |= (int(b) & 0x7F) << shift
2620 if b < 0x80 {
2621 break
2622 }
2623 }
2624 if msglen < 0 {
2625 return ErrInvalidLengthGenerated
2626 }
2627 postIndex := iNdEx + msglen
2628 if postIndex > l {
2629 return io.ErrUnexpectedEOF
2630 }
2631 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2632 return err
2633 }
2634 iNdEx = postIndex
2635 default:
2636 iNdEx = preIndex
2637 skippy, err := skipGenerated(dAtA[iNdEx:])
2638 if err != nil {
2639 return err
2640 }
2641 if skippy < 0 {
2642 return ErrInvalidLengthGenerated
2643 }
2644 if (iNdEx + skippy) > l {
2645 return io.ErrUnexpectedEOF
2646 }
2647 iNdEx += skippy
2648 }
2649 }
2650
2651 if iNdEx > l {
2652 return io.ErrUnexpectedEOF
2653 }
2654 return nil
2655}
2656func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
2657 l := len(dAtA)
2658 iNdEx := 0
2659 for iNdEx < l {
2660 preIndex := iNdEx
2661 var wire uint64
2662 for shift := uint(0); ; shift += 7 {
2663 if shift >= 64 {
2664 return ErrIntOverflowGenerated
2665 }
2666 if iNdEx >= l {
2667 return io.ErrUnexpectedEOF
2668 }
2669 b := dAtA[iNdEx]
2670 iNdEx++
2671 wire |= (uint64(b) & 0x7F) << shift
2672 if b < 0x80 {
2673 break
2674 }
2675 }
2676 fieldNum := int32(wire >> 3)
2677 wireType := int(wire & 0x7)
2678 if wireType == 4 {
2679 return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
2680 }
2681 if fieldNum <= 0 {
2682 return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
2683 }
2684 switch fieldNum {
2685 case 1:
2686 if wireType != 2 {
2687 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2688 }
2689 var stringLen uint64
2690 for shift := uint(0); ; shift += 7 {
2691 if shift >= 64 {
2692 return ErrIntOverflowGenerated
2693 }
2694 if iNdEx >= l {
2695 return io.ErrUnexpectedEOF
2696 }
2697 b := dAtA[iNdEx]
2698 iNdEx++
2699 stringLen |= (uint64(b) & 0x7F) << shift
2700 if b < 0x80 {
2701 break
2702 }
2703 }
2704 intStringLen := int(stringLen)
2705 if intStringLen < 0 {
2706 return ErrInvalidLengthGenerated
2707 }
2708 postIndex := iNdEx + intStringLen
2709 if postIndex > l {
2710 return io.ErrUnexpectedEOF
2711 }
2712 m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
2713 iNdEx = postIndex
2714 case 2:
2715 if wireType != 2 {
2716 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2717 }
2718 var stringLen uint64
2719 for shift := uint(0); ; shift += 7 {
2720 if shift >= 64 {
2721 return ErrIntOverflowGenerated
2722 }
2723 if iNdEx >= l {
2724 return io.ErrUnexpectedEOF
2725 }
2726 b := dAtA[iNdEx]
2727 iNdEx++
2728 stringLen |= (uint64(b) & 0x7F) << shift
2729 if b < 0x80 {
2730 break
2731 }
2732 }
2733 intStringLen := int(stringLen)
2734 if intStringLen < 0 {
2735 return ErrInvalidLengthGenerated
2736 }
2737 postIndex := iNdEx + intStringLen
2738 if postIndex > l {
2739 return io.ErrUnexpectedEOF
2740 }
2741 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
2742 iNdEx = postIndex
2743 case 3:
2744 if wireType != 2 {
2745 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
2746 }
2747 var msglen int
2748 for shift := uint(0); ; shift += 7 {
2749 if shift >= 64 {
2750 return ErrIntOverflowGenerated
2751 }
2752 if iNdEx >= l {
2753 return io.ErrUnexpectedEOF
2754 }
2755 b := dAtA[iNdEx]
2756 iNdEx++
2757 msglen |= (int(b) & 0x7F) << shift
2758 if b < 0x80 {
2759 break
2760 }
2761 }
2762 if msglen < 0 {
2763 return ErrInvalidLengthGenerated
2764 }
2765 postIndex := iNdEx + msglen
2766 if postIndex > l {
2767 return io.ErrUnexpectedEOF
2768 }
2769 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2770 return err
2771 }
2772 iNdEx = postIndex
2773 case 4:
2774 if wireType != 2 {
2775 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
2776 }
2777 var stringLen uint64
2778 for shift := uint(0); ; shift += 7 {
2779 if shift >= 64 {
2780 return ErrIntOverflowGenerated
2781 }
2782 if iNdEx >= l {
2783 return io.ErrUnexpectedEOF
2784 }
2785 b := dAtA[iNdEx]
2786 iNdEx++
2787 stringLen |= (uint64(b) & 0x7F) << shift
2788 if b < 0x80 {
2789 break
2790 }
2791 }
2792 intStringLen := int(stringLen)
2793 if intStringLen < 0 {
2794 return ErrInvalidLengthGenerated
2795 }
2796 postIndex := iNdEx + intStringLen
2797 if postIndex > l {
2798 return io.ErrUnexpectedEOF
2799 }
2800 m.Reason = string(dAtA[iNdEx:postIndex])
2801 iNdEx = postIndex
2802 case 5:
2803 if wireType != 2 {
2804 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
2805 }
2806 var stringLen uint64
2807 for shift := uint(0); ; shift += 7 {
2808 if shift >= 64 {
2809 return ErrIntOverflowGenerated
2810 }
2811 if iNdEx >= l {
2812 return io.ErrUnexpectedEOF
2813 }
2814 b := dAtA[iNdEx]
2815 iNdEx++
2816 stringLen |= (uint64(b) & 0x7F) << shift
2817 if b < 0x80 {
2818 break
2819 }
2820 }
2821 intStringLen := int(stringLen)
2822 if intStringLen < 0 {
2823 return ErrInvalidLengthGenerated
2824 }
2825 postIndex := iNdEx + intStringLen
2826 if postIndex > l {
2827 return io.ErrUnexpectedEOF
2828 }
2829 m.Message = string(dAtA[iNdEx:postIndex])
2830 iNdEx = postIndex
2831 default:
2832 iNdEx = preIndex
2833 skippy, err := skipGenerated(dAtA[iNdEx:])
2834 if err != nil {
2835 return err
2836 }
2837 if skippy < 0 {
2838 return ErrInvalidLengthGenerated
2839 }
2840 if (iNdEx + skippy) > l {
2841 return io.ErrUnexpectedEOF
2842 }
2843 iNdEx += skippy
2844 }
2845 }
2846
2847 if iNdEx > l {
2848 return io.ErrUnexpectedEOF
2849 }
2850 return nil
2851}
2852func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
2853 l := len(dAtA)
2854 iNdEx := 0
2855 for iNdEx < l {
2856 preIndex := iNdEx
2857 var wire uint64
2858 for shift := uint(0); ; shift += 7 {
2859 if shift >= 64 {
2860 return ErrIntOverflowGenerated
2861 }
2862 if iNdEx >= l {
2863 return io.ErrUnexpectedEOF
2864 }
2865 b := dAtA[iNdEx]
2866 iNdEx++
2867 wire |= (uint64(b) & 0x7F) << shift
2868 if b < 0x80 {
2869 break
2870 }
2871 }
2872 fieldNum := int32(wire >> 3)
2873 wireType := int(wire & 0x7)
2874 if wireType == 4 {
2875 return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
2876 }
2877 if fieldNum <= 0 {
2878 return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
2879 }
2880 switch fieldNum {
2881 case 1:
2882 if wireType != 2 {
2883 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2884 }
2885 var msglen int
2886 for shift := uint(0); ; shift += 7 {
2887 if shift >= 64 {
2888 return ErrIntOverflowGenerated
2889 }
2890 if iNdEx >= l {
2891 return io.ErrUnexpectedEOF
2892 }
2893 b := dAtA[iNdEx]
2894 iNdEx++
2895 msglen |= (int(b) & 0x7F) << shift
2896 if b < 0x80 {
2897 break
2898 }
2899 }
2900 if msglen < 0 {
2901 return ErrInvalidLengthGenerated
2902 }
2903 postIndex := iNdEx + msglen
2904 if postIndex > l {
2905 return io.ErrUnexpectedEOF
2906 }
2907 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2908 return err
2909 }
2910 iNdEx = postIndex
2911 case 2:
2912 if wireType != 2 {
2913 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2914 }
2915 var msglen int
2916 for shift := uint(0); ; shift += 7 {
2917 if shift >= 64 {
2918 return ErrIntOverflowGenerated
2919 }
2920 if iNdEx >= l {
2921 return io.ErrUnexpectedEOF
2922 }
2923 b := dAtA[iNdEx]
2924 iNdEx++
2925 msglen |= (int(b) & 0x7F) << shift
2926 if b < 0x80 {
2927 break
2928 }
2929 }
2930 if msglen < 0 {
2931 return ErrInvalidLengthGenerated
2932 }
2933 postIndex := iNdEx + msglen
2934 if postIndex > l {
2935 return io.ErrUnexpectedEOF
2936 }
2937 m.Items = append(m.Items, DaemonSet{})
2938 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2939 return err
2940 }
2941 iNdEx = postIndex
2942 default:
2943 iNdEx = preIndex
2944 skippy, err := skipGenerated(dAtA[iNdEx:])
2945 if err != nil {
2946 return err
2947 }
2948 if skippy < 0 {
2949 return ErrInvalidLengthGenerated
2950 }
2951 if (iNdEx + skippy) > l {
2952 return io.ErrUnexpectedEOF
2953 }
2954 iNdEx += skippy
2955 }
2956 }
2957
2958 if iNdEx > l {
2959 return io.ErrUnexpectedEOF
2960 }
2961 return nil
2962}
2963func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
2964 l := len(dAtA)
2965 iNdEx := 0
2966 for iNdEx < l {
2967 preIndex := iNdEx
2968 var wire uint64
2969 for shift := uint(0); ; shift += 7 {
2970 if shift >= 64 {
2971 return ErrIntOverflowGenerated
2972 }
2973 if iNdEx >= l {
2974 return io.ErrUnexpectedEOF
2975 }
2976 b := dAtA[iNdEx]
2977 iNdEx++
2978 wire |= (uint64(b) & 0x7F) << shift
2979 if b < 0x80 {
2980 break
2981 }
2982 }
2983 fieldNum := int32(wire >> 3)
2984 wireType := int(wire & 0x7)
2985 if wireType == 4 {
2986 return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
2987 }
2988 if fieldNum <= 0 {
2989 return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2990 }
2991 switch fieldNum {
2992 case 1:
2993 if wireType != 2 {
2994 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
2995 }
2996 var msglen int
2997 for shift := uint(0); ; shift += 7 {
2998 if shift >= 64 {
2999 return ErrIntOverflowGenerated
3000 }
3001 if iNdEx >= l {
3002 return io.ErrUnexpectedEOF
3003 }
3004 b := dAtA[iNdEx]
3005 iNdEx++
3006 msglen |= (int(b) & 0x7F) << shift
3007 if b < 0x80 {
3008 break
3009 }
3010 }
3011 if msglen < 0 {
3012 return ErrInvalidLengthGenerated
3013 }
3014 postIndex := iNdEx + msglen
3015 if postIndex > l {
3016 return io.ErrUnexpectedEOF
3017 }
3018 if m.Selector == nil {
3019 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
3020 }
3021 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3022 return err
3023 }
3024 iNdEx = postIndex
3025 case 2:
3026 if wireType != 2 {
3027 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
3028 }
3029 var msglen int
3030 for shift := uint(0); ; shift += 7 {
3031 if shift >= 64 {
3032 return ErrIntOverflowGenerated
3033 }
3034 if iNdEx >= l {
3035 return io.ErrUnexpectedEOF
3036 }
3037 b := dAtA[iNdEx]
3038 iNdEx++
3039 msglen |= (int(b) & 0x7F) << shift
3040 if b < 0x80 {
3041 break
3042 }
3043 }
3044 if msglen < 0 {
3045 return ErrInvalidLengthGenerated
3046 }
3047 postIndex := iNdEx + msglen
3048 if postIndex > l {
3049 return io.ErrUnexpectedEOF
3050 }
3051 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3052 return err
3053 }
3054 iNdEx = postIndex
3055 case 3:
3056 if wireType != 2 {
3057 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
3058 }
3059 var msglen int
3060 for shift := uint(0); ; shift += 7 {
3061 if shift >= 64 {
3062 return ErrIntOverflowGenerated
3063 }
3064 if iNdEx >= l {
3065 return io.ErrUnexpectedEOF
3066 }
3067 b := dAtA[iNdEx]
3068 iNdEx++
3069 msglen |= (int(b) & 0x7F) << shift
3070 if b < 0x80 {
3071 break
3072 }
3073 }
3074 if msglen < 0 {
3075 return ErrInvalidLengthGenerated
3076 }
3077 postIndex := iNdEx + msglen
3078 if postIndex > l {
3079 return io.ErrUnexpectedEOF
3080 }
3081 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3082 return err
3083 }
3084 iNdEx = postIndex
3085 case 4:
3086 if wireType != 0 {
3087 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
3088 }
3089 m.MinReadySeconds = 0
3090 for shift := uint(0); ; shift += 7 {
3091 if shift >= 64 {
3092 return ErrIntOverflowGenerated
3093 }
3094 if iNdEx >= l {
3095 return io.ErrUnexpectedEOF
3096 }
3097 b := dAtA[iNdEx]
3098 iNdEx++
3099 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
3100 if b < 0x80 {
3101 break
3102 }
3103 }
3104 case 6:
3105 if wireType != 0 {
3106 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
3107 }
3108 var v int32
3109 for shift := uint(0); ; shift += 7 {
3110 if shift >= 64 {
3111 return ErrIntOverflowGenerated
3112 }
3113 if iNdEx >= l {
3114 return io.ErrUnexpectedEOF
3115 }
3116 b := dAtA[iNdEx]
3117 iNdEx++
3118 v |= (int32(b) & 0x7F) << shift
3119 if b < 0x80 {
3120 break
3121 }
3122 }
3123 m.RevisionHistoryLimit = &v
3124 default:
3125 iNdEx = preIndex
3126 skippy, err := skipGenerated(dAtA[iNdEx:])
3127 if err != nil {
3128 return err
3129 }
3130 if skippy < 0 {
3131 return ErrInvalidLengthGenerated
3132 }
3133 if (iNdEx + skippy) > l {
3134 return io.ErrUnexpectedEOF
3135 }
3136 iNdEx += skippy
3137 }
3138 }
3139
3140 if iNdEx > l {
3141 return io.ErrUnexpectedEOF
3142 }
3143 return nil
3144}
3145func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
3146 l := len(dAtA)
3147 iNdEx := 0
3148 for iNdEx < l {
3149 preIndex := iNdEx
3150 var wire uint64
3151 for shift := uint(0); ; shift += 7 {
3152 if shift >= 64 {
3153 return ErrIntOverflowGenerated
3154 }
3155 if iNdEx >= l {
3156 return io.ErrUnexpectedEOF
3157 }
3158 b := dAtA[iNdEx]
3159 iNdEx++
3160 wire |= (uint64(b) & 0x7F) << shift
3161 if b < 0x80 {
3162 break
3163 }
3164 }
3165 fieldNum := int32(wire >> 3)
3166 wireType := int(wire & 0x7)
3167 if wireType == 4 {
3168 return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
3169 }
3170 if fieldNum <= 0 {
3171 return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3172 }
3173 switch fieldNum {
3174 case 1:
3175 if wireType != 0 {
3176 return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
3177 }
3178 m.CurrentNumberScheduled = 0
3179 for shift := uint(0); ; shift += 7 {
3180 if shift >= 64 {
3181 return ErrIntOverflowGenerated
3182 }
3183 if iNdEx >= l {
3184 return io.ErrUnexpectedEOF
3185 }
3186 b := dAtA[iNdEx]
3187 iNdEx++
3188 m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift
3189 if b < 0x80 {
3190 break
3191 }
3192 }
3193 case 2:
3194 if wireType != 0 {
3195 return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
3196 }
3197 m.NumberMisscheduled = 0
3198 for shift := uint(0); ; shift += 7 {
3199 if shift >= 64 {
3200 return ErrIntOverflowGenerated
3201 }
3202 if iNdEx >= l {
3203 return io.ErrUnexpectedEOF
3204 }
3205 b := dAtA[iNdEx]
3206 iNdEx++
3207 m.NumberMisscheduled |= (int32(b) & 0x7F) << shift
3208 if b < 0x80 {
3209 break
3210 }
3211 }
3212 case 3:
3213 if wireType != 0 {
3214 return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
3215 }
3216 m.DesiredNumberScheduled = 0
3217 for shift := uint(0); ; shift += 7 {
3218 if shift >= 64 {
3219 return ErrIntOverflowGenerated
3220 }
3221 if iNdEx >= l {
3222 return io.ErrUnexpectedEOF
3223 }
3224 b := dAtA[iNdEx]
3225 iNdEx++
3226 m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift
3227 if b < 0x80 {
3228 break
3229 }
3230 }
3231 case 4:
3232 if wireType != 0 {
3233 return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
3234 }
3235 m.NumberReady = 0
3236 for shift := uint(0); ; shift += 7 {
3237 if shift >= 64 {
3238 return ErrIntOverflowGenerated
3239 }
3240 if iNdEx >= l {
3241 return io.ErrUnexpectedEOF
3242 }
3243 b := dAtA[iNdEx]
3244 iNdEx++
3245 m.NumberReady |= (int32(b) & 0x7F) << shift
3246 if b < 0x80 {
3247 break
3248 }
3249 }
3250 case 5:
3251 if wireType != 0 {
3252 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
3253 }
3254 m.ObservedGeneration = 0
3255 for shift := uint(0); ; shift += 7 {
3256 if shift >= 64 {
3257 return ErrIntOverflowGenerated
3258 }
3259 if iNdEx >= l {
3260 return io.ErrUnexpectedEOF
3261 }
3262 b := dAtA[iNdEx]
3263 iNdEx++
3264 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
3265 if b < 0x80 {
3266 break
3267 }
3268 }
3269 case 6:
3270 if wireType != 0 {
3271 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
3272 }
3273 m.UpdatedNumberScheduled = 0
3274 for shift := uint(0); ; shift += 7 {
3275 if shift >= 64 {
3276 return ErrIntOverflowGenerated
3277 }
3278 if iNdEx >= l {
3279 return io.ErrUnexpectedEOF
3280 }
3281 b := dAtA[iNdEx]
3282 iNdEx++
3283 m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift
3284 if b < 0x80 {
3285 break
3286 }
3287 }
3288 case 7:
3289 if wireType != 0 {
3290 return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
3291 }
3292 m.NumberAvailable = 0
3293 for shift := uint(0); ; shift += 7 {
3294 if shift >= 64 {
3295 return ErrIntOverflowGenerated
3296 }
3297 if iNdEx >= l {
3298 return io.ErrUnexpectedEOF
3299 }
3300 b := dAtA[iNdEx]
3301 iNdEx++
3302 m.NumberAvailable |= (int32(b) & 0x7F) << shift
3303 if b < 0x80 {
3304 break
3305 }
3306 }
3307 case 8:
3308 if wireType != 0 {
3309 return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
3310 }
3311 m.NumberUnavailable = 0
3312 for shift := uint(0); ; shift += 7 {
3313 if shift >= 64 {
3314 return ErrIntOverflowGenerated
3315 }
3316 if iNdEx >= l {
3317 return io.ErrUnexpectedEOF
3318 }
3319 b := dAtA[iNdEx]
3320 iNdEx++
3321 m.NumberUnavailable |= (int32(b) & 0x7F) << shift
3322 if b < 0x80 {
3323 break
3324 }
3325 }
3326 case 9:
3327 if wireType != 0 {
3328 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
3329 }
3330 var v int32
3331 for shift := uint(0); ; shift += 7 {
3332 if shift >= 64 {
3333 return ErrIntOverflowGenerated
3334 }
3335 if iNdEx >= l {
3336 return io.ErrUnexpectedEOF
3337 }
3338 b := dAtA[iNdEx]
3339 iNdEx++
3340 v |= (int32(b) & 0x7F) << shift
3341 if b < 0x80 {
3342 break
3343 }
3344 }
3345 m.CollisionCount = &v
3346 case 10:
3347 if wireType != 2 {
3348 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
3349 }
3350 var msglen int
3351 for shift := uint(0); ; shift += 7 {
3352 if shift >= 64 {
3353 return ErrIntOverflowGenerated
3354 }
3355 if iNdEx >= l {
3356 return io.ErrUnexpectedEOF
3357 }
3358 b := dAtA[iNdEx]
3359 iNdEx++
3360 msglen |= (int(b) & 0x7F) << shift
3361 if b < 0x80 {
3362 break
3363 }
3364 }
3365 if msglen < 0 {
3366 return ErrInvalidLengthGenerated
3367 }
3368 postIndex := iNdEx + msglen
3369 if postIndex > l {
3370 return io.ErrUnexpectedEOF
3371 }
3372 m.Conditions = append(m.Conditions, DaemonSetCondition{})
3373 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3374 return err
3375 }
3376 iNdEx = postIndex
3377 default:
3378 iNdEx = preIndex
3379 skippy, err := skipGenerated(dAtA[iNdEx:])
3380 if err != nil {
3381 return err
3382 }
3383 if skippy < 0 {
3384 return ErrInvalidLengthGenerated
3385 }
3386 if (iNdEx + skippy) > l {
3387 return io.ErrUnexpectedEOF
3388 }
3389 iNdEx += skippy
3390 }
3391 }
3392
3393 if iNdEx > l {
3394 return io.ErrUnexpectedEOF
3395 }
3396 return nil
3397}
3398func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
3399 l := len(dAtA)
3400 iNdEx := 0
3401 for iNdEx < l {
3402 preIndex := iNdEx
3403 var wire uint64
3404 for shift := uint(0); ; shift += 7 {
3405 if shift >= 64 {
3406 return ErrIntOverflowGenerated
3407 }
3408 if iNdEx >= l {
3409 return io.ErrUnexpectedEOF
3410 }
3411 b := dAtA[iNdEx]
3412 iNdEx++
3413 wire |= (uint64(b) & 0x7F) << shift
3414 if b < 0x80 {
3415 break
3416 }
3417 }
3418 fieldNum := int32(wire >> 3)
3419 wireType := int(wire & 0x7)
3420 if wireType == 4 {
3421 return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
3422 }
3423 if fieldNum <= 0 {
3424 return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
3425 }
3426 switch fieldNum {
3427 case 1:
3428 if wireType != 2 {
3429 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3430 }
3431 var stringLen uint64
3432 for shift := uint(0); ; shift += 7 {
3433 if shift >= 64 {
3434 return ErrIntOverflowGenerated
3435 }
3436 if iNdEx >= l {
3437 return io.ErrUnexpectedEOF
3438 }
3439 b := dAtA[iNdEx]
3440 iNdEx++
3441 stringLen |= (uint64(b) & 0x7F) << shift
3442 if b < 0x80 {
3443 break
3444 }
3445 }
3446 intStringLen := int(stringLen)
3447 if intStringLen < 0 {
3448 return ErrInvalidLengthGenerated
3449 }
3450 postIndex := iNdEx + intStringLen
3451 if postIndex > l {
3452 return io.ErrUnexpectedEOF
3453 }
3454 m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
3455 iNdEx = postIndex
3456 case 2:
3457 if wireType != 2 {
3458 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
3459 }
3460 var msglen int
3461 for shift := uint(0); ; shift += 7 {
3462 if shift >= 64 {
3463 return ErrIntOverflowGenerated
3464 }
3465 if iNdEx >= l {
3466 return io.ErrUnexpectedEOF
3467 }
3468 b := dAtA[iNdEx]
3469 iNdEx++
3470 msglen |= (int(b) & 0x7F) << shift
3471 if b < 0x80 {
3472 break
3473 }
3474 }
3475 if msglen < 0 {
3476 return ErrInvalidLengthGenerated
3477 }
3478 postIndex := iNdEx + msglen
3479 if postIndex > l {
3480 return io.ErrUnexpectedEOF
3481 }
3482 if m.RollingUpdate == nil {
3483 m.RollingUpdate = &RollingUpdateDaemonSet{}
3484 }
3485 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3486 return err
3487 }
3488 iNdEx = postIndex
3489 default:
3490 iNdEx = preIndex
3491 skippy, err := skipGenerated(dAtA[iNdEx:])
3492 if err != nil {
3493 return err
3494 }
3495 if skippy < 0 {
3496 return ErrInvalidLengthGenerated
3497 }
3498 if (iNdEx + skippy) > l {
3499 return io.ErrUnexpectedEOF
3500 }
3501 iNdEx += skippy
3502 }
3503 }
3504
3505 if iNdEx > l {
3506 return io.ErrUnexpectedEOF
3507 }
3508 return nil
3509}
3510func (m *Deployment) Unmarshal(dAtA []byte) error {
3511 l := len(dAtA)
3512 iNdEx := 0
3513 for iNdEx < l {
3514 preIndex := iNdEx
3515 var wire uint64
3516 for shift := uint(0); ; shift += 7 {
3517 if shift >= 64 {
3518 return ErrIntOverflowGenerated
3519 }
3520 if iNdEx >= l {
3521 return io.ErrUnexpectedEOF
3522 }
3523 b := dAtA[iNdEx]
3524 iNdEx++
3525 wire |= (uint64(b) & 0x7F) << shift
3526 if b < 0x80 {
3527 break
3528 }
3529 }
3530 fieldNum := int32(wire >> 3)
3531 wireType := int(wire & 0x7)
3532 if wireType == 4 {
3533 return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
3534 }
3535 if fieldNum <= 0 {
3536 return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
3537 }
3538 switch fieldNum {
3539 case 1:
3540 if wireType != 2 {
3541 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3542 }
3543 var msglen int
3544 for shift := uint(0); ; shift += 7 {
3545 if shift >= 64 {
3546 return ErrIntOverflowGenerated
3547 }
3548 if iNdEx >= l {
3549 return io.ErrUnexpectedEOF
3550 }
3551 b := dAtA[iNdEx]
3552 iNdEx++
3553 msglen |= (int(b) & 0x7F) << shift
3554 if b < 0x80 {
3555 break
3556 }
3557 }
3558 if msglen < 0 {
3559 return ErrInvalidLengthGenerated
3560 }
3561 postIndex := iNdEx + msglen
3562 if postIndex > l {
3563 return io.ErrUnexpectedEOF
3564 }
3565 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3566 return err
3567 }
3568 iNdEx = postIndex
3569 case 2:
3570 if wireType != 2 {
3571 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3572 }
3573 var msglen int
3574 for shift := uint(0); ; shift += 7 {
3575 if shift >= 64 {
3576 return ErrIntOverflowGenerated
3577 }
3578 if iNdEx >= l {
3579 return io.ErrUnexpectedEOF
3580 }
3581 b := dAtA[iNdEx]
3582 iNdEx++
3583 msglen |= (int(b) & 0x7F) << shift
3584 if b < 0x80 {
3585 break
3586 }
3587 }
3588 if msglen < 0 {
3589 return ErrInvalidLengthGenerated
3590 }
3591 postIndex := iNdEx + msglen
3592 if postIndex > l {
3593 return io.ErrUnexpectedEOF
3594 }
3595 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3596 return err
3597 }
3598 iNdEx = postIndex
3599 case 3:
3600 if wireType != 2 {
3601 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3602 }
3603 var msglen int
3604 for shift := uint(0); ; shift += 7 {
3605 if shift >= 64 {
3606 return ErrIntOverflowGenerated
3607 }
3608 if iNdEx >= l {
3609 return io.ErrUnexpectedEOF
3610 }
3611 b := dAtA[iNdEx]
3612 iNdEx++
3613 msglen |= (int(b) & 0x7F) << shift
3614 if b < 0x80 {
3615 break
3616 }
3617 }
3618 if msglen < 0 {
3619 return ErrInvalidLengthGenerated
3620 }
3621 postIndex := iNdEx + msglen
3622 if postIndex > l {
3623 return io.ErrUnexpectedEOF
3624 }
3625 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3626 return err
3627 }
3628 iNdEx = postIndex
3629 default:
3630 iNdEx = preIndex
3631 skippy, err := skipGenerated(dAtA[iNdEx:])
3632 if err != nil {
3633 return err
3634 }
3635 if skippy < 0 {
3636 return ErrInvalidLengthGenerated
3637 }
3638 if (iNdEx + skippy) > l {
3639 return io.ErrUnexpectedEOF
3640 }
3641 iNdEx += skippy
3642 }
3643 }
3644
3645 if iNdEx > l {
3646 return io.ErrUnexpectedEOF
3647 }
3648 return nil
3649}
3650func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
3651 l := len(dAtA)
3652 iNdEx := 0
3653 for iNdEx < l {
3654 preIndex := iNdEx
3655 var wire uint64
3656 for shift := uint(0); ; shift += 7 {
3657 if shift >= 64 {
3658 return ErrIntOverflowGenerated
3659 }
3660 if iNdEx >= l {
3661 return io.ErrUnexpectedEOF
3662 }
3663 b := dAtA[iNdEx]
3664 iNdEx++
3665 wire |= (uint64(b) & 0x7F) << shift
3666 if b < 0x80 {
3667 break
3668 }
3669 }
3670 fieldNum := int32(wire >> 3)
3671 wireType := int(wire & 0x7)
3672 if wireType == 4 {
3673 return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
3674 }
3675 if fieldNum <= 0 {
3676 return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
3677 }
3678 switch fieldNum {
3679 case 1:
3680 if wireType != 2 {
3681 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3682 }
3683 var stringLen uint64
3684 for shift := uint(0); ; shift += 7 {
3685 if shift >= 64 {
3686 return ErrIntOverflowGenerated
3687 }
3688 if iNdEx >= l {
3689 return io.ErrUnexpectedEOF
3690 }
3691 b := dAtA[iNdEx]
3692 iNdEx++
3693 stringLen |= (uint64(b) & 0x7F) << shift
3694 if b < 0x80 {
3695 break
3696 }
3697 }
3698 intStringLen := int(stringLen)
3699 if intStringLen < 0 {
3700 return ErrInvalidLengthGenerated
3701 }
3702 postIndex := iNdEx + intStringLen
3703 if postIndex > l {
3704 return io.ErrUnexpectedEOF
3705 }
3706 m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
3707 iNdEx = postIndex
3708 case 2:
3709 if wireType != 2 {
3710 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3711 }
3712 var stringLen uint64
3713 for shift := uint(0); ; shift += 7 {
3714 if shift >= 64 {
3715 return ErrIntOverflowGenerated
3716 }
3717 if iNdEx >= l {
3718 return io.ErrUnexpectedEOF
3719 }
3720 b := dAtA[iNdEx]
3721 iNdEx++
3722 stringLen |= (uint64(b) & 0x7F) << shift
3723 if b < 0x80 {
3724 break
3725 }
3726 }
3727 intStringLen := int(stringLen)
3728 if intStringLen < 0 {
3729 return ErrInvalidLengthGenerated
3730 }
3731 postIndex := iNdEx + intStringLen
3732 if postIndex > l {
3733 return io.ErrUnexpectedEOF
3734 }
3735 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
3736 iNdEx = postIndex
3737 case 4:
3738 if wireType != 2 {
3739 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3740 }
3741 var stringLen uint64
3742 for shift := uint(0); ; shift += 7 {
3743 if shift >= 64 {
3744 return ErrIntOverflowGenerated
3745 }
3746 if iNdEx >= l {
3747 return io.ErrUnexpectedEOF
3748 }
3749 b := dAtA[iNdEx]
3750 iNdEx++
3751 stringLen |= (uint64(b) & 0x7F) << shift
3752 if b < 0x80 {
3753 break
3754 }
3755 }
3756 intStringLen := int(stringLen)
3757 if intStringLen < 0 {
3758 return ErrInvalidLengthGenerated
3759 }
3760 postIndex := iNdEx + intStringLen
3761 if postIndex > l {
3762 return io.ErrUnexpectedEOF
3763 }
3764 m.Reason = string(dAtA[iNdEx:postIndex])
3765 iNdEx = postIndex
3766 case 5:
3767 if wireType != 2 {
3768 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
3769 }
3770 var stringLen uint64
3771 for shift := uint(0); ; shift += 7 {
3772 if shift >= 64 {
3773 return ErrIntOverflowGenerated
3774 }
3775 if iNdEx >= l {
3776 return io.ErrUnexpectedEOF
3777 }
3778 b := dAtA[iNdEx]
3779 iNdEx++
3780 stringLen |= (uint64(b) & 0x7F) << shift
3781 if b < 0x80 {
3782 break
3783 }
3784 }
3785 intStringLen := int(stringLen)
3786 if intStringLen < 0 {
3787 return ErrInvalidLengthGenerated
3788 }
3789 postIndex := iNdEx + intStringLen
3790 if postIndex > l {
3791 return io.ErrUnexpectedEOF
3792 }
3793 m.Message = string(dAtA[iNdEx:postIndex])
3794 iNdEx = postIndex
3795 case 6:
3796 if wireType != 2 {
3797 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
3798 }
3799 var msglen int
3800 for shift := uint(0); ; shift += 7 {
3801 if shift >= 64 {
3802 return ErrIntOverflowGenerated
3803 }
3804 if iNdEx >= l {
3805 return io.ErrUnexpectedEOF
3806 }
3807 b := dAtA[iNdEx]
3808 iNdEx++
3809 msglen |= (int(b) & 0x7F) << shift
3810 if b < 0x80 {
3811 break
3812 }
3813 }
3814 if msglen < 0 {
3815 return ErrInvalidLengthGenerated
3816 }
3817 postIndex := iNdEx + msglen
3818 if postIndex > l {
3819 return io.ErrUnexpectedEOF
3820 }
3821 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3822 return err
3823 }
3824 iNdEx = postIndex
3825 case 7:
3826 if wireType != 2 {
3827 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
3828 }
3829 var msglen int
3830 for shift := uint(0); ; shift += 7 {
3831 if shift >= 64 {
3832 return ErrIntOverflowGenerated
3833 }
3834 if iNdEx >= l {
3835 return io.ErrUnexpectedEOF
3836 }
3837 b := dAtA[iNdEx]
3838 iNdEx++
3839 msglen |= (int(b) & 0x7F) << shift
3840 if b < 0x80 {
3841 break
3842 }
3843 }
3844 if msglen < 0 {
3845 return ErrInvalidLengthGenerated
3846 }
3847 postIndex := iNdEx + msglen
3848 if postIndex > l {
3849 return io.ErrUnexpectedEOF
3850 }
3851 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3852 return err
3853 }
3854 iNdEx = postIndex
3855 default:
3856 iNdEx = preIndex
3857 skippy, err := skipGenerated(dAtA[iNdEx:])
3858 if err != nil {
3859 return err
3860 }
3861 if skippy < 0 {
3862 return ErrInvalidLengthGenerated
3863 }
3864 if (iNdEx + skippy) > l {
3865 return io.ErrUnexpectedEOF
3866 }
3867 iNdEx += skippy
3868 }
3869 }
3870
3871 if iNdEx > l {
3872 return io.ErrUnexpectedEOF
3873 }
3874 return nil
3875}
3876func (m *DeploymentList) Unmarshal(dAtA []byte) error {
3877 l := len(dAtA)
3878 iNdEx := 0
3879 for iNdEx < l {
3880 preIndex := iNdEx
3881 var wire uint64
3882 for shift := uint(0); ; shift += 7 {
3883 if shift >= 64 {
3884 return ErrIntOverflowGenerated
3885 }
3886 if iNdEx >= l {
3887 return io.ErrUnexpectedEOF
3888 }
3889 b := dAtA[iNdEx]
3890 iNdEx++
3891 wire |= (uint64(b) & 0x7F) << shift
3892 if b < 0x80 {
3893 break
3894 }
3895 }
3896 fieldNum := int32(wire >> 3)
3897 wireType := int(wire & 0x7)
3898 if wireType == 4 {
3899 return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
3900 }
3901 if fieldNum <= 0 {
3902 return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
3903 }
3904 switch fieldNum {
3905 case 1:
3906 if wireType != 2 {
3907 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3908 }
3909 var msglen int
3910 for shift := uint(0); ; shift += 7 {
3911 if shift >= 64 {
3912 return ErrIntOverflowGenerated
3913 }
3914 if iNdEx >= l {
3915 return io.ErrUnexpectedEOF
3916 }
3917 b := dAtA[iNdEx]
3918 iNdEx++
3919 msglen |= (int(b) & 0x7F) << shift
3920 if b < 0x80 {
3921 break
3922 }
3923 }
3924 if msglen < 0 {
3925 return ErrInvalidLengthGenerated
3926 }
3927 postIndex := iNdEx + msglen
3928 if postIndex > l {
3929 return io.ErrUnexpectedEOF
3930 }
3931 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3932 return err
3933 }
3934 iNdEx = postIndex
3935 case 2:
3936 if wireType != 2 {
3937 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3938 }
3939 var msglen int
3940 for shift := uint(0); ; shift += 7 {
3941 if shift >= 64 {
3942 return ErrIntOverflowGenerated
3943 }
3944 if iNdEx >= l {
3945 return io.ErrUnexpectedEOF
3946 }
3947 b := dAtA[iNdEx]
3948 iNdEx++
3949 msglen |= (int(b) & 0x7F) << shift
3950 if b < 0x80 {
3951 break
3952 }
3953 }
3954 if msglen < 0 {
3955 return ErrInvalidLengthGenerated
3956 }
3957 postIndex := iNdEx + msglen
3958 if postIndex > l {
3959 return io.ErrUnexpectedEOF
3960 }
3961 m.Items = append(m.Items, Deployment{})
3962 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3963 return err
3964 }
3965 iNdEx = postIndex
3966 default:
3967 iNdEx = preIndex
3968 skippy, err := skipGenerated(dAtA[iNdEx:])
3969 if err != nil {
3970 return err
3971 }
3972 if skippy < 0 {
3973 return ErrInvalidLengthGenerated
3974 }
3975 if (iNdEx + skippy) > l {
3976 return io.ErrUnexpectedEOF
3977 }
3978 iNdEx += skippy
3979 }
3980 }
3981
3982 if iNdEx > l {
3983 return io.ErrUnexpectedEOF
3984 }
3985 return nil
3986}
3987func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
3988 l := len(dAtA)
3989 iNdEx := 0
3990 for iNdEx < l {
3991 preIndex := iNdEx
3992 var wire uint64
3993 for shift := uint(0); ; shift += 7 {
3994 if shift >= 64 {
3995 return ErrIntOverflowGenerated
3996 }
3997 if iNdEx >= l {
3998 return io.ErrUnexpectedEOF
3999 }
4000 b := dAtA[iNdEx]
4001 iNdEx++
4002 wire |= (uint64(b) & 0x7F) << shift
4003 if b < 0x80 {
4004 break
4005 }
4006 }
4007 fieldNum := int32(wire >> 3)
4008 wireType := int(wire & 0x7)
4009 if wireType == 4 {
4010 return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
4011 }
4012 if fieldNum <= 0 {
4013 return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4014 }
4015 switch fieldNum {
4016 case 1:
4017 if wireType != 0 {
4018 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4019 }
4020 var v int32
4021 for shift := uint(0); ; shift += 7 {
4022 if shift >= 64 {
4023 return ErrIntOverflowGenerated
4024 }
4025 if iNdEx >= l {
4026 return io.ErrUnexpectedEOF
4027 }
4028 b := dAtA[iNdEx]
4029 iNdEx++
4030 v |= (int32(b) & 0x7F) << shift
4031 if b < 0x80 {
4032 break
4033 }
4034 }
4035 m.Replicas = &v
4036 case 2:
4037 if wireType != 2 {
4038 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
4039 }
4040 var msglen int
4041 for shift := uint(0); ; shift += 7 {
4042 if shift >= 64 {
4043 return ErrIntOverflowGenerated
4044 }
4045 if iNdEx >= l {
4046 return io.ErrUnexpectedEOF
4047 }
4048 b := dAtA[iNdEx]
4049 iNdEx++
4050 msglen |= (int(b) & 0x7F) << shift
4051 if b < 0x80 {
4052 break
4053 }
4054 }
4055 if msglen < 0 {
4056 return ErrInvalidLengthGenerated
4057 }
4058 postIndex := iNdEx + msglen
4059 if postIndex > l {
4060 return io.ErrUnexpectedEOF
4061 }
4062 if m.Selector == nil {
4063 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
4064 }
4065 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4066 return err
4067 }
4068 iNdEx = postIndex
4069 case 3:
4070 if wireType != 2 {
4071 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
4072 }
4073 var msglen int
4074 for shift := uint(0); ; shift += 7 {
4075 if shift >= 64 {
4076 return ErrIntOverflowGenerated
4077 }
4078 if iNdEx >= l {
4079 return io.ErrUnexpectedEOF
4080 }
4081 b := dAtA[iNdEx]
4082 iNdEx++
4083 msglen |= (int(b) & 0x7F) << shift
4084 if b < 0x80 {
4085 break
4086 }
4087 }
4088 if msglen < 0 {
4089 return ErrInvalidLengthGenerated
4090 }
4091 postIndex := iNdEx + msglen
4092 if postIndex > l {
4093 return io.ErrUnexpectedEOF
4094 }
4095 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4096 return err
4097 }
4098 iNdEx = postIndex
4099 case 4:
4100 if wireType != 2 {
4101 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
4102 }
4103 var msglen int
4104 for shift := uint(0); ; shift += 7 {
4105 if shift >= 64 {
4106 return ErrIntOverflowGenerated
4107 }
4108 if iNdEx >= l {
4109 return io.ErrUnexpectedEOF
4110 }
4111 b := dAtA[iNdEx]
4112 iNdEx++
4113 msglen |= (int(b) & 0x7F) << shift
4114 if b < 0x80 {
4115 break
4116 }
4117 }
4118 if msglen < 0 {
4119 return ErrInvalidLengthGenerated
4120 }
4121 postIndex := iNdEx + msglen
4122 if postIndex > l {
4123 return io.ErrUnexpectedEOF
4124 }
4125 if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4126 return err
4127 }
4128 iNdEx = postIndex
4129 case 5:
4130 if wireType != 0 {
4131 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
4132 }
4133 m.MinReadySeconds = 0
4134 for shift := uint(0); ; shift += 7 {
4135 if shift >= 64 {
4136 return ErrIntOverflowGenerated
4137 }
4138 if iNdEx >= l {
4139 return io.ErrUnexpectedEOF
4140 }
4141 b := dAtA[iNdEx]
4142 iNdEx++
4143 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
4144 if b < 0x80 {
4145 break
4146 }
4147 }
4148 case 6:
4149 if wireType != 0 {
4150 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
4151 }
4152 var v int32
4153 for shift := uint(0); ; shift += 7 {
4154 if shift >= 64 {
4155 return ErrIntOverflowGenerated
4156 }
4157 if iNdEx >= l {
4158 return io.ErrUnexpectedEOF
4159 }
4160 b := dAtA[iNdEx]
4161 iNdEx++
4162 v |= (int32(b) & 0x7F) << shift
4163 if b < 0x80 {
4164 break
4165 }
4166 }
4167 m.RevisionHistoryLimit = &v
4168 case 7:
4169 if wireType != 0 {
4170 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
4171 }
4172 var v int
4173 for shift := uint(0); ; shift += 7 {
4174 if shift >= 64 {
4175 return ErrIntOverflowGenerated
4176 }
4177 if iNdEx >= l {
4178 return io.ErrUnexpectedEOF
4179 }
4180 b := dAtA[iNdEx]
4181 iNdEx++
4182 v |= (int(b) & 0x7F) << shift
4183 if b < 0x80 {
4184 break
4185 }
4186 }
4187 m.Paused = bool(v != 0)
4188 case 9:
4189 if wireType != 0 {
4190 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
4191 }
4192 var v int32
4193 for shift := uint(0); ; shift += 7 {
4194 if shift >= 64 {
4195 return ErrIntOverflowGenerated
4196 }
4197 if iNdEx >= l {
4198 return io.ErrUnexpectedEOF
4199 }
4200 b := dAtA[iNdEx]
4201 iNdEx++
4202 v |= (int32(b) & 0x7F) << shift
4203 if b < 0x80 {
4204 break
4205 }
4206 }
4207 m.ProgressDeadlineSeconds = &v
4208 default:
4209 iNdEx = preIndex
4210 skippy, err := skipGenerated(dAtA[iNdEx:])
4211 if err != nil {
4212 return err
4213 }
4214 if skippy < 0 {
4215 return ErrInvalidLengthGenerated
4216 }
4217 if (iNdEx + skippy) > l {
4218 return io.ErrUnexpectedEOF
4219 }
4220 iNdEx += skippy
4221 }
4222 }
4223
4224 if iNdEx > l {
4225 return io.ErrUnexpectedEOF
4226 }
4227 return nil
4228}
4229func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
4230 l := len(dAtA)
4231 iNdEx := 0
4232 for iNdEx < l {
4233 preIndex := iNdEx
4234 var wire uint64
4235 for shift := uint(0); ; shift += 7 {
4236 if shift >= 64 {
4237 return ErrIntOverflowGenerated
4238 }
4239 if iNdEx >= l {
4240 return io.ErrUnexpectedEOF
4241 }
4242 b := dAtA[iNdEx]
4243 iNdEx++
4244 wire |= (uint64(b) & 0x7F) << shift
4245 if b < 0x80 {
4246 break
4247 }
4248 }
4249 fieldNum := int32(wire >> 3)
4250 wireType := int(wire & 0x7)
4251 if wireType == 4 {
4252 return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
4253 }
4254 if fieldNum <= 0 {
4255 return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4256 }
4257 switch fieldNum {
4258 case 1:
4259 if wireType != 0 {
4260 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
4261 }
4262 m.ObservedGeneration = 0
4263 for shift := uint(0); ; shift += 7 {
4264 if shift >= 64 {
4265 return ErrIntOverflowGenerated
4266 }
4267 if iNdEx >= l {
4268 return io.ErrUnexpectedEOF
4269 }
4270 b := dAtA[iNdEx]
4271 iNdEx++
4272 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
4273 if b < 0x80 {
4274 break
4275 }
4276 }
4277 case 2:
4278 if wireType != 0 {
4279 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4280 }
4281 m.Replicas = 0
4282 for shift := uint(0); ; shift += 7 {
4283 if shift >= 64 {
4284 return ErrIntOverflowGenerated
4285 }
4286 if iNdEx >= l {
4287 return io.ErrUnexpectedEOF
4288 }
4289 b := dAtA[iNdEx]
4290 iNdEx++
4291 m.Replicas |= (int32(b) & 0x7F) << shift
4292 if b < 0x80 {
4293 break
4294 }
4295 }
4296 case 3:
4297 if wireType != 0 {
4298 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
4299 }
4300 m.UpdatedReplicas = 0
4301 for shift := uint(0); ; shift += 7 {
4302 if shift >= 64 {
4303 return ErrIntOverflowGenerated
4304 }
4305 if iNdEx >= l {
4306 return io.ErrUnexpectedEOF
4307 }
4308 b := dAtA[iNdEx]
4309 iNdEx++
4310 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
4311 if b < 0x80 {
4312 break
4313 }
4314 }
4315 case 4:
4316 if wireType != 0 {
4317 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
4318 }
4319 m.AvailableReplicas = 0
4320 for shift := uint(0); ; shift += 7 {
4321 if shift >= 64 {
4322 return ErrIntOverflowGenerated
4323 }
4324 if iNdEx >= l {
4325 return io.ErrUnexpectedEOF
4326 }
4327 b := dAtA[iNdEx]
4328 iNdEx++
4329 m.AvailableReplicas |= (int32(b) & 0x7F) << shift
4330 if b < 0x80 {
4331 break
4332 }
4333 }
4334 case 5:
4335 if wireType != 0 {
4336 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
4337 }
4338 m.UnavailableReplicas = 0
4339 for shift := uint(0); ; shift += 7 {
4340 if shift >= 64 {
4341 return ErrIntOverflowGenerated
4342 }
4343 if iNdEx >= l {
4344 return io.ErrUnexpectedEOF
4345 }
4346 b := dAtA[iNdEx]
4347 iNdEx++
4348 m.UnavailableReplicas |= (int32(b) & 0x7F) << shift
4349 if b < 0x80 {
4350 break
4351 }
4352 }
4353 case 6:
4354 if wireType != 2 {
4355 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4356 }
4357 var msglen int
4358 for shift := uint(0); ; shift += 7 {
4359 if shift >= 64 {
4360 return ErrIntOverflowGenerated
4361 }
4362 if iNdEx >= l {
4363 return io.ErrUnexpectedEOF
4364 }
4365 b := dAtA[iNdEx]
4366 iNdEx++
4367 msglen |= (int(b) & 0x7F) << shift
4368 if b < 0x80 {
4369 break
4370 }
4371 }
4372 if msglen < 0 {
4373 return ErrInvalidLengthGenerated
4374 }
4375 postIndex := iNdEx + msglen
4376 if postIndex > l {
4377 return io.ErrUnexpectedEOF
4378 }
4379 m.Conditions = append(m.Conditions, DeploymentCondition{})
4380 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4381 return err
4382 }
4383 iNdEx = postIndex
4384 case 7:
4385 if wireType != 0 {
4386 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
4387 }
4388 m.ReadyReplicas = 0
4389 for shift := uint(0); ; shift += 7 {
4390 if shift >= 64 {
4391 return ErrIntOverflowGenerated
4392 }
4393 if iNdEx >= l {
4394 return io.ErrUnexpectedEOF
4395 }
4396 b := dAtA[iNdEx]
4397 iNdEx++
4398 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
4399 if b < 0x80 {
4400 break
4401 }
4402 }
4403 case 8:
4404 if wireType != 0 {
4405 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
4406 }
4407 var v int32
4408 for shift := uint(0); ; shift += 7 {
4409 if shift >= 64 {
4410 return ErrIntOverflowGenerated
4411 }
4412 if iNdEx >= l {
4413 return io.ErrUnexpectedEOF
4414 }
4415 b := dAtA[iNdEx]
4416 iNdEx++
4417 v |= (int32(b) & 0x7F) << shift
4418 if b < 0x80 {
4419 break
4420 }
4421 }
4422 m.CollisionCount = &v
4423 default:
4424 iNdEx = preIndex
4425 skippy, err := skipGenerated(dAtA[iNdEx:])
4426 if err != nil {
4427 return err
4428 }
4429 if skippy < 0 {
4430 return ErrInvalidLengthGenerated
4431 }
4432 if (iNdEx + skippy) > l {
4433 return io.ErrUnexpectedEOF
4434 }
4435 iNdEx += skippy
4436 }
4437 }
4438
4439 if iNdEx > l {
4440 return io.ErrUnexpectedEOF
4441 }
4442 return nil
4443}
4444func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
4445 l := len(dAtA)
4446 iNdEx := 0
4447 for iNdEx < l {
4448 preIndex := iNdEx
4449 var wire uint64
4450 for shift := uint(0); ; shift += 7 {
4451 if shift >= 64 {
4452 return ErrIntOverflowGenerated
4453 }
4454 if iNdEx >= l {
4455 return io.ErrUnexpectedEOF
4456 }
4457 b := dAtA[iNdEx]
4458 iNdEx++
4459 wire |= (uint64(b) & 0x7F) << shift
4460 if b < 0x80 {
4461 break
4462 }
4463 }
4464 fieldNum := int32(wire >> 3)
4465 wireType := int(wire & 0x7)
4466 if wireType == 4 {
4467 return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
4468 }
4469 if fieldNum <= 0 {
4470 return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
4471 }
4472 switch fieldNum {
4473 case 1:
4474 if wireType != 2 {
4475 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4476 }
4477 var stringLen uint64
4478 for shift := uint(0); ; shift += 7 {
4479 if shift >= 64 {
4480 return ErrIntOverflowGenerated
4481 }
4482 if iNdEx >= l {
4483 return io.ErrUnexpectedEOF
4484 }
4485 b := dAtA[iNdEx]
4486 iNdEx++
4487 stringLen |= (uint64(b) & 0x7F) << shift
4488 if b < 0x80 {
4489 break
4490 }
4491 }
4492 intStringLen := int(stringLen)
4493 if intStringLen < 0 {
4494 return ErrInvalidLengthGenerated
4495 }
4496 postIndex := iNdEx + intStringLen
4497 if postIndex > l {
4498 return io.ErrUnexpectedEOF
4499 }
4500 m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
4501 iNdEx = postIndex
4502 case 2:
4503 if wireType != 2 {
4504 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
4505 }
4506 var msglen int
4507 for shift := uint(0); ; shift += 7 {
4508 if shift >= 64 {
4509 return ErrIntOverflowGenerated
4510 }
4511 if iNdEx >= l {
4512 return io.ErrUnexpectedEOF
4513 }
4514 b := dAtA[iNdEx]
4515 iNdEx++
4516 msglen |= (int(b) & 0x7F) << shift
4517 if b < 0x80 {
4518 break
4519 }
4520 }
4521 if msglen < 0 {
4522 return ErrInvalidLengthGenerated
4523 }
4524 postIndex := iNdEx + msglen
4525 if postIndex > l {
4526 return io.ErrUnexpectedEOF
4527 }
4528 if m.RollingUpdate == nil {
4529 m.RollingUpdate = &RollingUpdateDeployment{}
4530 }
4531 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4532 return err
4533 }
4534 iNdEx = postIndex
4535 default:
4536 iNdEx = preIndex
4537 skippy, err := skipGenerated(dAtA[iNdEx:])
4538 if err != nil {
4539 return err
4540 }
4541 if skippy < 0 {
4542 return ErrInvalidLengthGenerated
4543 }
4544 if (iNdEx + skippy) > l {
4545 return io.ErrUnexpectedEOF
4546 }
4547 iNdEx += skippy
4548 }
4549 }
4550
4551 if iNdEx > l {
4552 return io.ErrUnexpectedEOF
4553 }
4554 return nil
4555}
4556func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
4557 l := len(dAtA)
4558 iNdEx := 0
4559 for iNdEx < l {
4560 preIndex := iNdEx
4561 var wire uint64
4562 for shift := uint(0); ; shift += 7 {
4563 if shift >= 64 {
4564 return ErrIntOverflowGenerated
4565 }
4566 if iNdEx >= l {
4567 return io.ErrUnexpectedEOF
4568 }
4569 b := dAtA[iNdEx]
4570 iNdEx++
4571 wire |= (uint64(b) & 0x7F) << shift
4572 if b < 0x80 {
4573 break
4574 }
4575 }
4576 fieldNum := int32(wire >> 3)
4577 wireType := int(wire & 0x7)
4578 if wireType == 4 {
4579 return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
4580 }
4581 if fieldNum <= 0 {
4582 return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
4583 }
4584 switch fieldNum {
4585 case 1:
4586 if wireType != 2 {
4587 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4588 }
4589 var msglen int
4590 for shift := uint(0); ; shift += 7 {
4591 if shift >= 64 {
4592 return ErrIntOverflowGenerated
4593 }
4594 if iNdEx >= l {
4595 return io.ErrUnexpectedEOF
4596 }
4597 b := dAtA[iNdEx]
4598 iNdEx++
4599 msglen |= (int(b) & 0x7F) << shift
4600 if b < 0x80 {
4601 break
4602 }
4603 }
4604 if msglen < 0 {
4605 return ErrInvalidLengthGenerated
4606 }
4607 postIndex := iNdEx + msglen
4608 if postIndex > l {
4609 return io.ErrUnexpectedEOF
4610 }
4611 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4612 return err
4613 }
4614 iNdEx = postIndex
4615 case 2:
4616 if wireType != 2 {
4617 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4618 }
4619 var msglen int
4620 for shift := uint(0); ; shift += 7 {
4621 if shift >= 64 {
4622 return ErrIntOverflowGenerated
4623 }
4624 if iNdEx >= l {
4625 return io.ErrUnexpectedEOF
4626 }
4627 b := dAtA[iNdEx]
4628 iNdEx++
4629 msglen |= (int(b) & 0x7F) << shift
4630 if b < 0x80 {
4631 break
4632 }
4633 }
4634 if msglen < 0 {
4635 return ErrInvalidLengthGenerated
4636 }
4637 postIndex := iNdEx + msglen
4638 if postIndex > l {
4639 return io.ErrUnexpectedEOF
4640 }
4641 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4642 return err
4643 }
4644 iNdEx = postIndex
4645 case 3:
4646 if wireType != 2 {
4647 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4648 }
4649 var msglen int
4650 for shift := uint(0); ; shift += 7 {
4651 if shift >= 64 {
4652 return ErrIntOverflowGenerated
4653 }
4654 if iNdEx >= l {
4655 return io.ErrUnexpectedEOF
4656 }
4657 b := dAtA[iNdEx]
4658 iNdEx++
4659 msglen |= (int(b) & 0x7F) << shift
4660 if b < 0x80 {
4661 break
4662 }
4663 }
4664 if msglen < 0 {
4665 return ErrInvalidLengthGenerated
4666 }
4667 postIndex := iNdEx + msglen
4668 if postIndex > l {
4669 return io.ErrUnexpectedEOF
4670 }
4671 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4672 return err
4673 }
4674 iNdEx = postIndex
4675 default:
4676 iNdEx = preIndex
4677 skippy, err := skipGenerated(dAtA[iNdEx:])
4678 if err != nil {
4679 return err
4680 }
4681 if skippy < 0 {
4682 return ErrInvalidLengthGenerated
4683 }
4684 if (iNdEx + skippy) > l {
4685 return io.ErrUnexpectedEOF
4686 }
4687 iNdEx += skippy
4688 }
4689 }
4690
4691 if iNdEx > l {
4692 return io.ErrUnexpectedEOF
4693 }
4694 return nil
4695}
4696func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
4697 l := len(dAtA)
4698 iNdEx := 0
4699 for iNdEx < l {
4700 preIndex := iNdEx
4701 var wire uint64
4702 for shift := uint(0); ; shift += 7 {
4703 if shift >= 64 {
4704 return ErrIntOverflowGenerated
4705 }
4706 if iNdEx >= l {
4707 return io.ErrUnexpectedEOF
4708 }
4709 b := dAtA[iNdEx]
4710 iNdEx++
4711 wire |= (uint64(b) & 0x7F) << shift
4712 if b < 0x80 {
4713 break
4714 }
4715 }
4716 fieldNum := int32(wire >> 3)
4717 wireType := int(wire & 0x7)
4718 if wireType == 4 {
4719 return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
4720 }
4721 if fieldNum <= 0 {
4722 return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
4723 }
4724 switch fieldNum {
4725 case 1:
4726 if wireType != 2 {
4727 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4728 }
4729 var stringLen uint64
4730 for shift := uint(0); ; shift += 7 {
4731 if shift >= 64 {
4732 return ErrIntOverflowGenerated
4733 }
4734 if iNdEx >= l {
4735 return io.ErrUnexpectedEOF
4736 }
4737 b := dAtA[iNdEx]
4738 iNdEx++
4739 stringLen |= (uint64(b) & 0x7F) << shift
4740 if b < 0x80 {
4741 break
4742 }
4743 }
4744 intStringLen := int(stringLen)
4745 if intStringLen < 0 {
4746 return ErrInvalidLengthGenerated
4747 }
4748 postIndex := iNdEx + intStringLen
4749 if postIndex > l {
4750 return io.ErrUnexpectedEOF
4751 }
4752 m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
4753 iNdEx = postIndex
4754 case 2:
4755 if wireType != 2 {
4756 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4757 }
4758 var stringLen uint64
4759 for shift := uint(0); ; shift += 7 {
4760 if shift >= 64 {
4761 return ErrIntOverflowGenerated
4762 }
4763 if iNdEx >= l {
4764 return io.ErrUnexpectedEOF
4765 }
4766 b := dAtA[iNdEx]
4767 iNdEx++
4768 stringLen |= (uint64(b) & 0x7F) << shift
4769 if b < 0x80 {
4770 break
4771 }
4772 }
4773 intStringLen := int(stringLen)
4774 if intStringLen < 0 {
4775 return ErrInvalidLengthGenerated
4776 }
4777 postIndex := iNdEx + intStringLen
4778 if postIndex > l {
4779 return io.ErrUnexpectedEOF
4780 }
4781 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
4782 iNdEx = postIndex
4783 case 3:
4784 if wireType != 2 {
4785 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
4786 }
4787 var msglen int
4788 for shift := uint(0); ; shift += 7 {
4789 if shift >= 64 {
4790 return ErrIntOverflowGenerated
4791 }
4792 if iNdEx >= l {
4793 return io.ErrUnexpectedEOF
4794 }
4795 b := dAtA[iNdEx]
4796 iNdEx++
4797 msglen |= (int(b) & 0x7F) << shift
4798 if b < 0x80 {
4799 break
4800 }
4801 }
4802 if msglen < 0 {
4803 return ErrInvalidLengthGenerated
4804 }
4805 postIndex := iNdEx + msglen
4806 if postIndex > l {
4807 return io.ErrUnexpectedEOF
4808 }
4809 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4810 return err
4811 }
4812 iNdEx = postIndex
4813 case 4:
4814 if wireType != 2 {
4815 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
4816 }
4817 var stringLen uint64
4818 for shift := uint(0); ; shift += 7 {
4819 if shift >= 64 {
4820 return ErrIntOverflowGenerated
4821 }
4822 if iNdEx >= l {
4823 return io.ErrUnexpectedEOF
4824 }
4825 b := dAtA[iNdEx]
4826 iNdEx++
4827 stringLen |= (uint64(b) & 0x7F) << shift
4828 if b < 0x80 {
4829 break
4830 }
4831 }
4832 intStringLen := int(stringLen)
4833 if intStringLen < 0 {
4834 return ErrInvalidLengthGenerated
4835 }
4836 postIndex := iNdEx + intStringLen
4837 if postIndex > l {
4838 return io.ErrUnexpectedEOF
4839 }
4840 m.Reason = string(dAtA[iNdEx:postIndex])
4841 iNdEx = postIndex
4842 case 5:
4843 if wireType != 2 {
4844 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
4845 }
4846 var stringLen uint64
4847 for shift := uint(0); ; shift += 7 {
4848 if shift >= 64 {
4849 return ErrIntOverflowGenerated
4850 }
4851 if iNdEx >= l {
4852 return io.ErrUnexpectedEOF
4853 }
4854 b := dAtA[iNdEx]
4855 iNdEx++
4856 stringLen |= (uint64(b) & 0x7F) << shift
4857 if b < 0x80 {
4858 break
4859 }
4860 }
4861 intStringLen := int(stringLen)
4862 if intStringLen < 0 {
4863 return ErrInvalidLengthGenerated
4864 }
4865 postIndex := iNdEx + intStringLen
4866 if postIndex > l {
4867 return io.ErrUnexpectedEOF
4868 }
4869 m.Message = string(dAtA[iNdEx:postIndex])
4870 iNdEx = postIndex
4871 default:
4872 iNdEx = preIndex
4873 skippy, err := skipGenerated(dAtA[iNdEx:])
4874 if err != nil {
4875 return err
4876 }
4877 if skippy < 0 {
4878 return ErrInvalidLengthGenerated
4879 }
4880 if (iNdEx + skippy) > l {
4881 return io.ErrUnexpectedEOF
4882 }
4883 iNdEx += skippy
4884 }
4885 }
4886
4887 if iNdEx > l {
4888 return io.ErrUnexpectedEOF
4889 }
4890 return nil
4891}
4892func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
4893 l := len(dAtA)
4894 iNdEx := 0
4895 for iNdEx < l {
4896 preIndex := iNdEx
4897 var wire uint64
4898 for shift := uint(0); ; shift += 7 {
4899 if shift >= 64 {
4900 return ErrIntOverflowGenerated
4901 }
4902 if iNdEx >= l {
4903 return io.ErrUnexpectedEOF
4904 }
4905 b := dAtA[iNdEx]
4906 iNdEx++
4907 wire |= (uint64(b) & 0x7F) << shift
4908 if b < 0x80 {
4909 break
4910 }
4911 }
4912 fieldNum := int32(wire >> 3)
4913 wireType := int(wire & 0x7)
4914 if wireType == 4 {
4915 return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
4916 }
4917 if fieldNum <= 0 {
4918 return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
4919 }
4920 switch fieldNum {
4921 case 1:
4922 if wireType != 2 {
4923 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4924 }
4925 var msglen int
4926 for shift := uint(0); ; shift += 7 {
4927 if shift >= 64 {
4928 return ErrIntOverflowGenerated
4929 }
4930 if iNdEx >= l {
4931 return io.ErrUnexpectedEOF
4932 }
4933 b := dAtA[iNdEx]
4934 iNdEx++
4935 msglen |= (int(b) & 0x7F) << shift
4936 if b < 0x80 {
4937 break
4938 }
4939 }
4940 if msglen < 0 {
4941 return ErrInvalidLengthGenerated
4942 }
4943 postIndex := iNdEx + msglen
4944 if postIndex > l {
4945 return io.ErrUnexpectedEOF
4946 }
4947 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4948 return err
4949 }
4950 iNdEx = postIndex
4951 case 2:
4952 if wireType != 2 {
4953 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4954 }
4955 var msglen int
4956 for shift := uint(0); ; shift += 7 {
4957 if shift >= 64 {
4958 return ErrIntOverflowGenerated
4959 }
4960 if iNdEx >= l {
4961 return io.ErrUnexpectedEOF
4962 }
4963 b := dAtA[iNdEx]
4964 iNdEx++
4965 msglen |= (int(b) & 0x7F) << shift
4966 if b < 0x80 {
4967 break
4968 }
4969 }
4970 if msglen < 0 {
4971 return ErrInvalidLengthGenerated
4972 }
4973 postIndex := iNdEx + msglen
4974 if postIndex > l {
4975 return io.ErrUnexpectedEOF
4976 }
4977 m.Items = append(m.Items, ReplicaSet{})
4978 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4979 return err
4980 }
4981 iNdEx = postIndex
4982 default:
4983 iNdEx = preIndex
4984 skippy, err := skipGenerated(dAtA[iNdEx:])
4985 if err != nil {
4986 return err
4987 }
4988 if skippy < 0 {
4989 return ErrInvalidLengthGenerated
4990 }
4991 if (iNdEx + skippy) > l {
4992 return io.ErrUnexpectedEOF
4993 }
4994 iNdEx += skippy
4995 }
4996 }
4997
4998 if iNdEx > l {
4999 return io.ErrUnexpectedEOF
5000 }
5001 return nil
5002}
5003func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
5004 l := len(dAtA)
5005 iNdEx := 0
5006 for iNdEx < l {
5007 preIndex := iNdEx
5008 var wire uint64
5009 for shift := uint(0); ; shift += 7 {
5010 if shift >= 64 {
5011 return ErrIntOverflowGenerated
5012 }
5013 if iNdEx >= l {
5014 return io.ErrUnexpectedEOF
5015 }
5016 b := dAtA[iNdEx]
5017 iNdEx++
5018 wire |= (uint64(b) & 0x7F) << shift
5019 if b < 0x80 {
5020 break
5021 }
5022 }
5023 fieldNum := int32(wire >> 3)
5024 wireType := int(wire & 0x7)
5025 if wireType == 4 {
5026 return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
5027 }
5028 if fieldNum <= 0 {
5029 return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5030 }
5031 switch fieldNum {
5032 case 1:
5033 if wireType != 0 {
5034 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5035 }
5036 var v int32
5037 for shift := uint(0); ; shift += 7 {
5038 if shift >= 64 {
5039 return ErrIntOverflowGenerated
5040 }
5041 if iNdEx >= l {
5042 return io.ErrUnexpectedEOF
5043 }
5044 b := dAtA[iNdEx]
5045 iNdEx++
5046 v |= (int32(b) & 0x7F) << shift
5047 if b < 0x80 {
5048 break
5049 }
5050 }
5051 m.Replicas = &v
5052 case 2:
5053 if wireType != 2 {
5054 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5055 }
5056 var msglen int
5057 for shift := uint(0); ; shift += 7 {
5058 if shift >= 64 {
5059 return ErrIntOverflowGenerated
5060 }
5061 if iNdEx >= l {
5062 return io.ErrUnexpectedEOF
5063 }
5064 b := dAtA[iNdEx]
5065 iNdEx++
5066 msglen |= (int(b) & 0x7F) << shift
5067 if b < 0x80 {
5068 break
5069 }
5070 }
5071 if msglen < 0 {
5072 return ErrInvalidLengthGenerated
5073 }
5074 postIndex := iNdEx + msglen
5075 if postIndex > l {
5076 return io.ErrUnexpectedEOF
5077 }
5078 if m.Selector == nil {
5079 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
5080 }
5081 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5082 return err
5083 }
5084 iNdEx = postIndex
5085 case 3:
5086 if wireType != 2 {
5087 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
5088 }
5089 var msglen int
5090 for shift := uint(0); ; shift += 7 {
5091 if shift >= 64 {
5092 return ErrIntOverflowGenerated
5093 }
5094 if iNdEx >= l {
5095 return io.ErrUnexpectedEOF
5096 }
5097 b := dAtA[iNdEx]
5098 iNdEx++
5099 msglen |= (int(b) & 0x7F) << shift
5100 if b < 0x80 {
5101 break
5102 }
5103 }
5104 if msglen < 0 {
5105 return ErrInvalidLengthGenerated
5106 }
5107 postIndex := iNdEx + msglen
5108 if postIndex > l {
5109 return io.ErrUnexpectedEOF
5110 }
5111 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5112 return err
5113 }
5114 iNdEx = postIndex
5115 case 4:
5116 if wireType != 0 {
5117 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
5118 }
5119 m.MinReadySeconds = 0
5120 for shift := uint(0); ; shift += 7 {
5121 if shift >= 64 {
5122 return ErrIntOverflowGenerated
5123 }
5124 if iNdEx >= l {
5125 return io.ErrUnexpectedEOF
5126 }
5127 b := dAtA[iNdEx]
5128 iNdEx++
5129 m.MinReadySeconds |= (int32(b) & 0x7F) << shift
5130 if b < 0x80 {
5131 break
5132 }
5133 }
5134 default:
5135 iNdEx = preIndex
5136 skippy, err := skipGenerated(dAtA[iNdEx:])
5137 if err != nil {
5138 return err
5139 }
5140 if skippy < 0 {
5141 return ErrInvalidLengthGenerated
5142 }
5143 if (iNdEx + skippy) > l {
5144 return io.ErrUnexpectedEOF
5145 }
5146 iNdEx += skippy
5147 }
5148 }
5149
5150 if iNdEx > l {
5151 return io.ErrUnexpectedEOF
5152 }
5153 return nil
5154}
5155func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
5156 l := len(dAtA)
5157 iNdEx := 0
5158 for iNdEx < l {
5159 preIndex := iNdEx
5160 var wire uint64
5161 for shift := uint(0); ; shift += 7 {
5162 if shift >= 64 {
5163 return ErrIntOverflowGenerated
5164 }
5165 if iNdEx >= l {
5166 return io.ErrUnexpectedEOF
5167 }
5168 b := dAtA[iNdEx]
5169 iNdEx++
5170 wire |= (uint64(b) & 0x7F) << shift
5171 if b < 0x80 {
5172 break
5173 }
5174 }
5175 fieldNum := int32(wire >> 3)
5176 wireType := int(wire & 0x7)
5177 if wireType == 4 {
5178 return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
5179 }
5180 if fieldNum <= 0 {
5181 return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5182 }
5183 switch fieldNum {
5184 case 1:
5185 if wireType != 0 {
5186 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5187 }
5188 m.Replicas = 0
5189 for shift := uint(0); ; shift += 7 {
5190 if shift >= 64 {
5191 return ErrIntOverflowGenerated
5192 }
5193 if iNdEx >= l {
5194 return io.ErrUnexpectedEOF
5195 }
5196 b := dAtA[iNdEx]
5197 iNdEx++
5198 m.Replicas |= (int32(b) & 0x7F) << shift
5199 if b < 0x80 {
5200 break
5201 }
5202 }
5203 case 2:
5204 if wireType != 0 {
5205 return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
5206 }
5207 m.FullyLabeledReplicas = 0
5208 for shift := uint(0); ; shift += 7 {
5209 if shift >= 64 {
5210 return ErrIntOverflowGenerated
5211 }
5212 if iNdEx >= l {
5213 return io.ErrUnexpectedEOF
5214 }
5215 b := dAtA[iNdEx]
5216 iNdEx++
5217 m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift
5218 if b < 0x80 {
5219 break
5220 }
5221 }
5222 case 3:
5223 if wireType != 0 {
5224 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
5225 }
5226 m.ObservedGeneration = 0
5227 for shift := uint(0); ; shift += 7 {
5228 if shift >= 64 {
5229 return ErrIntOverflowGenerated
5230 }
5231 if iNdEx >= l {
5232 return io.ErrUnexpectedEOF
5233 }
5234 b := dAtA[iNdEx]
5235 iNdEx++
5236 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
5237 if b < 0x80 {
5238 break
5239 }
5240 }
5241 case 4:
5242 if wireType != 0 {
5243 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
5244 }
5245 m.ReadyReplicas = 0
5246 for shift := uint(0); ; shift += 7 {
5247 if shift >= 64 {
5248 return ErrIntOverflowGenerated
5249 }
5250 if iNdEx >= l {
5251 return io.ErrUnexpectedEOF
5252 }
5253 b := dAtA[iNdEx]
5254 iNdEx++
5255 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
5256 if b < 0x80 {
5257 break
5258 }
5259 }
5260 case 5:
5261 if wireType != 0 {
5262 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
5263 }
5264 m.AvailableReplicas = 0
5265 for shift := uint(0); ; shift += 7 {
5266 if shift >= 64 {
5267 return ErrIntOverflowGenerated
5268 }
5269 if iNdEx >= l {
5270 return io.ErrUnexpectedEOF
5271 }
5272 b := dAtA[iNdEx]
5273 iNdEx++
5274 m.AvailableReplicas |= (int32(b) & 0x7F) << shift
5275 if b < 0x80 {
5276 break
5277 }
5278 }
5279 case 6:
5280 if wireType != 2 {
5281 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
5282 }
5283 var msglen int
5284 for shift := uint(0); ; shift += 7 {
5285 if shift >= 64 {
5286 return ErrIntOverflowGenerated
5287 }
5288 if iNdEx >= l {
5289 return io.ErrUnexpectedEOF
5290 }
5291 b := dAtA[iNdEx]
5292 iNdEx++
5293 msglen |= (int(b) & 0x7F) << shift
5294 if b < 0x80 {
5295 break
5296 }
5297 }
5298 if msglen < 0 {
5299 return ErrInvalidLengthGenerated
5300 }
5301 postIndex := iNdEx + msglen
5302 if postIndex > l {
5303 return io.ErrUnexpectedEOF
5304 }
5305 m.Conditions = append(m.Conditions, ReplicaSetCondition{})
5306 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5307 return err
5308 }
5309 iNdEx = postIndex
5310 default:
5311 iNdEx = preIndex
5312 skippy, err := skipGenerated(dAtA[iNdEx:])
5313 if err != nil {
5314 return err
5315 }
5316 if skippy < 0 {
5317 return ErrInvalidLengthGenerated
5318 }
5319 if (iNdEx + skippy) > l {
5320 return io.ErrUnexpectedEOF
5321 }
5322 iNdEx += skippy
5323 }
5324 }
5325
5326 if iNdEx > l {
5327 return io.ErrUnexpectedEOF
5328 }
5329 return nil
5330}
5331func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
5332 l := len(dAtA)
5333 iNdEx := 0
5334 for iNdEx < l {
5335 preIndex := iNdEx
5336 var wire uint64
5337 for shift := uint(0); ; shift += 7 {
5338 if shift >= 64 {
5339 return ErrIntOverflowGenerated
5340 }
5341 if iNdEx >= l {
5342 return io.ErrUnexpectedEOF
5343 }
5344 b := dAtA[iNdEx]
5345 iNdEx++
5346 wire |= (uint64(b) & 0x7F) << shift
5347 if b < 0x80 {
5348 break
5349 }
5350 }
5351 fieldNum := int32(wire >> 3)
5352 wireType := int(wire & 0x7)
5353 if wireType == 4 {
5354 return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
5355 }
5356 if fieldNum <= 0 {
5357 return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
5358 }
5359 switch fieldNum {
5360 case 1:
5361 if wireType != 2 {
5362 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
5363 }
5364 var msglen int
5365 for shift := uint(0); ; shift += 7 {
5366 if shift >= 64 {
5367 return ErrIntOverflowGenerated
5368 }
5369 if iNdEx >= l {
5370 return io.ErrUnexpectedEOF
5371 }
5372 b := dAtA[iNdEx]
5373 iNdEx++
5374 msglen |= (int(b) & 0x7F) << shift
5375 if b < 0x80 {
5376 break
5377 }
5378 }
5379 if msglen < 0 {
5380 return ErrInvalidLengthGenerated
5381 }
5382 postIndex := iNdEx + msglen
5383 if postIndex > l {
5384 return io.ErrUnexpectedEOF
5385 }
5386 if m.MaxUnavailable == nil {
5387 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
5388 }
5389 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5390 return err
5391 }
5392 iNdEx = postIndex
5393 default:
5394 iNdEx = preIndex
5395 skippy, err := skipGenerated(dAtA[iNdEx:])
5396 if err != nil {
5397 return err
5398 }
5399 if skippy < 0 {
5400 return ErrInvalidLengthGenerated
5401 }
5402 if (iNdEx + skippy) > l {
5403 return io.ErrUnexpectedEOF
5404 }
5405 iNdEx += skippy
5406 }
5407 }
5408
5409 if iNdEx > l {
5410 return io.ErrUnexpectedEOF
5411 }
5412 return nil
5413}
5414func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
5415 l := len(dAtA)
5416 iNdEx := 0
5417 for iNdEx < l {
5418 preIndex := iNdEx
5419 var wire uint64
5420 for shift := uint(0); ; shift += 7 {
5421 if shift >= 64 {
5422 return ErrIntOverflowGenerated
5423 }
5424 if iNdEx >= l {
5425 return io.ErrUnexpectedEOF
5426 }
5427 b := dAtA[iNdEx]
5428 iNdEx++
5429 wire |= (uint64(b) & 0x7F) << shift
5430 if b < 0x80 {
5431 break
5432 }
5433 }
5434 fieldNum := int32(wire >> 3)
5435 wireType := int(wire & 0x7)
5436 if wireType == 4 {
5437 return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
5438 }
5439 if fieldNum <= 0 {
5440 return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
5441 }
5442 switch fieldNum {
5443 case 1:
5444 if wireType != 2 {
5445 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
5446 }
5447 var msglen int
5448 for shift := uint(0); ; shift += 7 {
5449 if shift >= 64 {
5450 return ErrIntOverflowGenerated
5451 }
5452 if iNdEx >= l {
5453 return io.ErrUnexpectedEOF
5454 }
5455 b := dAtA[iNdEx]
5456 iNdEx++
5457 msglen |= (int(b) & 0x7F) << shift
5458 if b < 0x80 {
5459 break
5460 }
5461 }
5462 if msglen < 0 {
5463 return ErrInvalidLengthGenerated
5464 }
5465 postIndex := iNdEx + msglen
5466 if postIndex > l {
5467 return io.ErrUnexpectedEOF
5468 }
5469 if m.MaxUnavailable == nil {
5470 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
5471 }
5472 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5473 return err
5474 }
5475 iNdEx = postIndex
5476 case 2:
5477 if wireType != 2 {
5478 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
5479 }
5480 var msglen int
5481 for shift := uint(0); ; shift += 7 {
5482 if shift >= 64 {
5483 return ErrIntOverflowGenerated
5484 }
5485 if iNdEx >= l {
5486 return io.ErrUnexpectedEOF
5487 }
5488 b := dAtA[iNdEx]
5489 iNdEx++
5490 msglen |= (int(b) & 0x7F) << shift
5491 if b < 0x80 {
5492 break
5493 }
5494 }
5495 if msglen < 0 {
5496 return ErrInvalidLengthGenerated
5497 }
5498 postIndex := iNdEx + msglen
5499 if postIndex > l {
5500 return io.ErrUnexpectedEOF
5501 }
5502 if m.MaxSurge == nil {
5503 m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{}
5504 }
5505 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5506 return err
5507 }
5508 iNdEx = postIndex
5509 default:
5510 iNdEx = preIndex
5511 skippy, err := skipGenerated(dAtA[iNdEx:])
5512 if err != nil {
5513 return err
5514 }
5515 if skippy < 0 {
5516 return ErrInvalidLengthGenerated
5517 }
5518 if (iNdEx + skippy) > l {
5519 return io.ErrUnexpectedEOF
5520 }
5521 iNdEx += skippy
5522 }
5523 }
5524
5525 if iNdEx > l {
5526 return io.ErrUnexpectedEOF
5527 }
5528 return nil
5529}
5530func (m *RollingUpdateStatefulSetStrategy) Unmarshal(dAtA []byte) error {
5531 l := len(dAtA)
5532 iNdEx := 0
5533 for iNdEx < l {
5534 preIndex := iNdEx
5535 var wire uint64
5536 for shift := uint(0); ; shift += 7 {
5537 if shift >= 64 {
5538 return ErrIntOverflowGenerated
5539 }
5540 if iNdEx >= l {
5541 return io.ErrUnexpectedEOF
5542 }
5543 b := dAtA[iNdEx]
5544 iNdEx++
5545 wire |= (uint64(b) & 0x7F) << shift
5546 if b < 0x80 {
5547 break
5548 }
5549 }
5550 fieldNum := int32(wire >> 3)
5551 wireType := int(wire & 0x7)
5552 if wireType == 4 {
5553 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: wiretype end group for non-group")
5554 }
5555 if fieldNum <= 0 {
5556 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
5557 }
5558 switch fieldNum {
5559 case 1:
5560 if wireType != 0 {
5561 return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
5562 }
5563 var v int32
5564 for shift := uint(0); ; shift += 7 {
5565 if shift >= 64 {
5566 return ErrIntOverflowGenerated
5567 }
5568 if iNdEx >= l {
5569 return io.ErrUnexpectedEOF
5570 }
5571 b := dAtA[iNdEx]
5572 iNdEx++
5573 v |= (int32(b) & 0x7F) << shift
5574 if b < 0x80 {
5575 break
5576 }
5577 }
5578 m.Partition = &v
5579 default:
5580 iNdEx = preIndex
5581 skippy, err := skipGenerated(dAtA[iNdEx:])
5582 if err != nil {
5583 return err
5584 }
5585 if skippy < 0 {
5586 return ErrInvalidLengthGenerated
5587 }
5588 if (iNdEx + skippy) > l {
5589 return io.ErrUnexpectedEOF
5590 }
5591 iNdEx += skippy
5592 }
5593 }
5594
5595 if iNdEx > l {
5596 return io.ErrUnexpectedEOF
5597 }
5598 return nil
5599}
5600func (m *StatefulSet) Unmarshal(dAtA []byte) error {
5601 l := len(dAtA)
5602 iNdEx := 0
5603 for iNdEx < l {
5604 preIndex := iNdEx
5605 var wire uint64
5606 for shift := uint(0); ; shift += 7 {
5607 if shift >= 64 {
5608 return ErrIntOverflowGenerated
5609 }
5610 if iNdEx >= l {
5611 return io.ErrUnexpectedEOF
5612 }
5613 b := dAtA[iNdEx]
5614 iNdEx++
5615 wire |= (uint64(b) & 0x7F) << shift
5616 if b < 0x80 {
5617 break
5618 }
5619 }
5620 fieldNum := int32(wire >> 3)
5621 wireType := int(wire & 0x7)
5622 if wireType == 4 {
5623 return fmt.Errorf("proto: StatefulSet: wiretype end group for non-group")
5624 }
5625 if fieldNum <= 0 {
5626 return fmt.Errorf("proto: StatefulSet: illegal tag %d (wire type %d)", fieldNum, wire)
5627 }
5628 switch fieldNum {
5629 case 1:
5630 if wireType != 2 {
5631 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5632 }
5633 var msglen int
5634 for shift := uint(0); ; shift += 7 {
5635 if shift >= 64 {
5636 return ErrIntOverflowGenerated
5637 }
5638 if iNdEx >= l {
5639 return io.ErrUnexpectedEOF
5640 }
5641 b := dAtA[iNdEx]
5642 iNdEx++
5643 msglen |= (int(b) & 0x7F) << shift
5644 if b < 0x80 {
5645 break
5646 }
5647 }
5648 if msglen < 0 {
5649 return ErrInvalidLengthGenerated
5650 }
5651 postIndex := iNdEx + msglen
5652 if postIndex > l {
5653 return io.ErrUnexpectedEOF
5654 }
5655 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5656 return err
5657 }
5658 iNdEx = postIndex
5659 case 2:
5660 if wireType != 2 {
5661 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5662 }
5663 var msglen int
5664 for shift := uint(0); ; shift += 7 {
5665 if shift >= 64 {
5666 return ErrIntOverflowGenerated
5667 }
5668 if iNdEx >= l {
5669 return io.ErrUnexpectedEOF
5670 }
5671 b := dAtA[iNdEx]
5672 iNdEx++
5673 msglen |= (int(b) & 0x7F) << shift
5674 if b < 0x80 {
5675 break
5676 }
5677 }
5678 if msglen < 0 {
5679 return ErrInvalidLengthGenerated
5680 }
5681 postIndex := iNdEx + msglen
5682 if postIndex > l {
5683 return io.ErrUnexpectedEOF
5684 }
5685 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5686 return err
5687 }
5688 iNdEx = postIndex
5689 case 3:
5690 if wireType != 2 {
5691 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5692 }
5693 var msglen int
5694 for shift := uint(0); ; shift += 7 {
5695 if shift >= 64 {
5696 return ErrIntOverflowGenerated
5697 }
5698 if iNdEx >= l {
5699 return io.ErrUnexpectedEOF
5700 }
5701 b := dAtA[iNdEx]
5702 iNdEx++
5703 msglen |= (int(b) & 0x7F) << shift
5704 if b < 0x80 {
5705 break
5706 }
5707 }
5708 if msglen < 0 {
5709 return ErrInvalidLengthGenerated
5710 }
5711 postIndex := iNdEx + msglen
5712 if postIndex > l {
5713 return io.ErrUnexpectedEOF
5714 }
5715 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5716 return err
5717 }
5718 iNdEx = postIndex
5719 default:
5720 iNdEx = preIndex
5721 skippy, err := skipGenerated(dAtA[iNdEx:])
5722 if err != nil {
5723 return err
5724 }
5725 if skippy < 0 {
5726 return ErrInvalidLengthGenerated
5727 }
5728 if (iNdEx + skippy) > l {
5729 return io.ErrUnexpectedEOF
5730 }
5731 iNdEx += skippy
5732 }
5733 }
5734
5735 if iNdEx > l {
5736 return io.ErrUnexpectedEOF
5737 }
5738 return nil
5739}
5740func (m *StatefulSetCondition) Unmarshal(dAtA []byte) error {
5741 l := len(dAtA)
5742 iNdEx := 0
5743 for iNdEx < l {
5744 preIndex := iNdEx
5745 var wire uint64
5746 for shift := uint(0); ; shift += 7 {
5747 if shift >= 64 {
5748 return ErrIntOverflowGenerated
5749 }
5750 if iNdEx >= l {
5751 return io.ErrUnexpectedEOF
5752 }
5753 b := dAtA[iNdEx]
5754 iNdEx++
5755 wire |= (uint64(b) & 0x7F) << shift
5756 if b < 0x80 {
5757 break
5758 }
5759 }
5760 fieldNum := int32(wire >> 3)
5761 wireType := int(wire & 0x7)
5762 if wireType == 4 {
5763 return fmt.Errorf("proto: StatefulSetCondition: wiretype end group for non-group")
5764 }
5765 if fieldNum <= 0 {
5766 return fmt.Errorf("proto: StatefulSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5767 }
5768 switch fieldNum {
5769 case 1:
5770 if wireType != 2 {
5771 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5772 }
5773 var stringLen uint64
5774 for shift := uint(0); ; shift += 7 {
5775 if shift >= 64 {
5776 return ErrIntOverflowGenerated
5777 }
5778 if iNdEx >= l {
5779 return io.ErrUnexpectedEOF
5780 }
5781 b := dAtA[iNdEx]
5782 iNdEx++
5783 stringLen |= (uint64(b) & 0x7F) << shift
5784 if b < 0x80 {
5785 break
5786 }
5787 }
5788 intStringLen := int(stringLen)
5789 if intStringLen < 0 {
5790 return ErrInvalidLengthGenerated
5791 }
5792 postIndex := iNdEx + intStringLen
5793 if postIndex > l {
5794 return io.ErrUnexpectedEOF
5795 }
5796 m.Type = StatefulSetConditionType(dAtA[iNdEx:postIndex])
5797 iNdEx = postIndex
5798 case 2:
5799 if wireType != 2 {
5800 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5801 }
5802 var stringLen uint64
5803 for shift := uint(0); ; shift += 7 {
5804 if shift >= 64 {
5805 return ErrIntOverflowGenerated
5806 }
5807 if iNdEx >= l {
5808 return io.ErrUnexpectedEOF
5809 }
5810 b := dAtA[iNdEx]
5811 iNdEx++
5812 stringLen |= (uint64(b) & 0x7F) << shift
5813 if b < 0x80 {
5814 break
5815 }
5816 }
5817 intStringLen := int(stringLen)
5818 if intStringLen < 0 {
5819 return ErrInvalidLengthGenerated
5820 }
5821 postIndex := iNdEx + intStringLen
5822 if postIndex > l {
5823 return io.ErrUnexpectedEOF
5824 }
5825 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5826 iNdEx = postIndex
5827 case 3:
5828 if wireType != 2 {
5829 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5830 }
5831 var msglen int
5832 for shift := uint(0); ; shift += 7 {
5833 if shift >= 64 {
5834 return ErrIntOverflowGenerated
5835 }
5836 if iNdEx >= l {
5837 return io.ErrUnexpectedEOF
5838 }
5839 b := dAtA[iNdEx]
5840 iNdEx++
5841 msglen |= (int(b) & 0x7F) << shift
5842 if b < 0x80 {
5843 break
5844 }
5845 }
5846 if msglen < 0 {
5847 return ErrInvalidLengthGenerated
5848 }
5849 postIndex := iNdEx + msglen
5850 if postIndex > l {
5851 return io.ErrUnexpectedEOF
5852 }
5853 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5854 return err
5855 }
5856 iNdEx = postIndex
5857 case 4:
5858 if wireType != 2 {
5859 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5860 }
5861 var stringLen uint64
5862 for shift := uint(0); ; shift += 7 {
5863 if shift >= 64 {
5864 return ErrIntOverflowGenerated
5865 }
5866 if iNdEx >= l {
5867 return io.ErrUnexpectedEOF
5868 }
5869 b := dAtA[iNdEx]
5870 iNdEx++
5871 stringLen |= (uint64(b) & 0x7F) << shift
5872 if b < 0x80 {
5873 break
5874 }
5875 }
5876 intStringLen := int(stringLen)
5877 if intStringLen < 0 {
5878 return ErrInvalidLengthGenerated
5879 }
5880 postIndex := iNdEx + intStringLen
5881 if postIndex > l {
5882 return io.ErrUnexpectedEOF
5883 }
5884 m.Reason = string(dAtA[iNdEx:postIndex])
5885 iNdEx = postIndex
5886 case 5:
5887 if wireType != 2 {
5888 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5889 }
5890 var stringLen uint64
5891 for shift := uint(0); ; shift += 7 {
5892 if shift >= 64 {
5893 return ErrIntOverflowGenerated
5894 }
5895 if iNdEx >= l {
5896 return io.ErrUnexpectedEOF
5897 }
5898 b := dAtA[iNdEx]
5899 iNdEx++
5900 stringLen |= (uint64(b) & 0x7F) << shift
5901 if b < 0x80 {
5902 break
5903 }
5904 }
5905 intStringLen := int(stringLen)
5906 if intStringLen < 0 {
5907 return ErrInvalidLengthGenerated
5908 }
5909 postIndex := iNdEx + intStringLen
5910 if postIndex > l {
5911 return io.ErrUnexpectedEOF
5912 }
5913 m.Message = string(dAtA[iNdEx:postIndex])
5914 iNdEx = postIndex
5915 default:
5916 iNdEx = preIndex
5917 skippy, err := skipGenerated(dAtA[iNdEx:])
5918 if err != nil {
5919 return err
5920 }
5921 if skippy < 0 {
5922 return ErrInvalidLengthGenerated
5923 }
5924 if (iNdEx + skippy) > l {
5925 return io.ErrUnexpectedEOF
5926 }
5927 iNdEx += skippy
5928 }
5929 }
5930
5931 if iNdEx > l {
5932 return io.ErrUnexpectedEOF
5933 }
5934 return nil
5935}
5936func (m *StatefulSetList) Unmarshal(dAtA []byte) error {
5937 l := len(dAtA)
5938 iNdEx := 0
5939 for iNdEx < l {
5940 preIndex := iNdEx
5941 var wire uint64
5942 for shift := uint(0); ; shift += 7 {
5943 if shift >= 64 {
5944 return ErrIntOverflowGenerated
5945 }
5946 if iNdEx >= l {
5947 return io.ErrUnexpectedEOF
5948 }
5949 b := dAtA[iNdEx]
5950 iNdEx++
5951 wire |= (uint64(b) & 0x7F) << shift
5952 if b < 0x80 {
5953 break
5954 }
5955 }
5956 fieldNum := int32(wire >> 3)
5957 wireType := int(wire & 0x7)
5958 if wireType == 4 {
5959 return fmt.Errorf("proto: StatefulSetList: wiretype end group for non-group")
5960 }
5961 if fieldNum <= 0 {
5962 return fmt.Errorf("proto: StatefulSetList: illegal tag %d (wire type %d)", fieldNum, wire)
5963 }
5964 switch fieldNum {
5965 case 1:
5966 if wireType != 2 {
5967 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5968 }
5969 var msglen int
5970 for shift := uint(0); ; shift += 7 {
5971 if shift >= 64 {
5972 return ErrIntOverflowGenerated
5973 }
5974 if iNdEx >= l {
5975 return io.ErrUnexpectedEOF
5976 }
5977 b := dAtA[iNdEx]
5978 iNdEx++
5979 msglen |= (int(b) & 0x7F) << shift
5980 if b < 0x80 {
5981 break
5982 }
5983 }
5984 if msglen < 0 {
5985 return ErrInvalidLengthGenerated
5986 }
5987 postIndex := iNdEx + msglen
5988 if postIndex > l {
5989 return io.ErrUnexpectedEOF
5990 }
5991 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5992 return err
5993 }
5994 iNdEx = postIndex
5995 case 2:
5996 if wireType != 2 {
5997 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5998 }
5999 var msglen int
6000 for shift := uint(0); ; shift += 7 {
6001 if shift >= 64 {
6002 return ErrIntOverflowGenerated
6003 }
6004 if iNdEx >= l {
6005 return io.ErrUnexpectedEOF
6006 }
6007 b := dAtA[iNdEx]
6008 iNdEx++
6009 msglen |= (int(b) & 0x7F) << shift
6010 if b < 0x80 {
6011 break
6012 }
6013 }
6014 if msglen < 0 {
6015 return ErrInvalidLengthGenerated
6016 }
6017 postIndex := iNdEx + msglen
6018 if postIndex > l {
6019 return io.ErrUnexpectedEOF
6020 }
6021 m.Items = append(m.Items, StatefulSet{})
6022 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6023 return err
6024 }
6025 iNdEx = postIndex
6026 default:
6027 iNdEx = preIndex
6028 skippy, err := skipGenerated(dAtA[iNdEx:])
6029 if err != nil {
6030 return err
6031 }
6032 if skippy < 0 {
6033 return ErrInvalidLengthGenerated
6034 }
6035 if (iNdEx + skippy) > l {
6036 return io.ErrUnexpectedEOF
6037 }
6038 iNdEx += skippy
6039 }
6040 }
6041
6042 if iNdEx > l {
6043 return io.ErrUnexpectedEOF
6044 }
6045 return nil
6046}
6047func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error {
6048 l := len(dAtA)
6049 iNdEx := 0
6050 for iNdEx < l {
6051 preIndex := iNdEx
6052 var wire uint64
6053 for shift := uint(0); ; shift += 7 {
6054 if shift >= 64 {
6055 return ErrIntOverflowGenerated
6056 }
6057 if iNdEx >= l {
6058 return io.ErrUnexpectedEOF
6059 }
6060 b := dAtA[iNdEx]
6061 iNdEx++
6062 wire |= (uint64(b) & 0x7F) << shift
6063 if b < 0x80 {
6064 break
6065 }
6066 }
6067 fieldNum := int32(wire >> 3)
6068 wireType := int(wire & 0x7)
6069 if wireType == 4 {
6070 return fmt.Errorf("proto: StatefulSetSpec: wiretype end group for non-group")
6071 }
6072 if fieldNum <= 0 {
6073 return fmt.Errorf("proto: StatefulSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
6074 }
6075 switch fieldNum {
6076 case 1:
6077 if wireType != 0 {
6078 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6079 }
6080 var v int32
6081 for shift := uint(0); ; shift += 7 {
6082 if shift >= 64 {
6083 return ErrIntOverflowGenerated
6084 }
6085 if iNdEx >= l {
6086 return io.ErrUnexpectedEOF
6087 }
6088 b := dAtA[iNdEx]
6089 iNdEx++
6090 v |= (int32(b) & 0x7F) << shift
6091 if b < 0x80 {
6092 break
6093 }
6094 }
6095 m.Replicas = &v
6096 case 2:
6097 if wireType != 2 {
6098 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
6099 }
6100 var msglen int
6101 for shift := uint(0); ; shift += 7 {
6102 if shift >= 64 {
6103 return ErrIntOverflowGenerated
6104 }
6105 if iNdEx >= l {
6106 return io.ErrUnexpectedEOF
6107 }
6108 b := dAtA[iNdEx]
6109 iNdEx++
6110 msglen |= (int(b) & 0x7F) << shift
6111 if b < 0x80 {
6112 break
6113 }
6114 }
6115 if msglen < 0 {
6116 return ErrInvalidLengthGenerated
6117 }
6118 postIndex := iNdEx + msglen
6119 if postIndex > l {
6120 return io.ErrUnexpectedEOF
6121 }
6122 if m.Selector == nil {
6123 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
6124 }
6125 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6126 return err
6127 }
6128 iNdEx = postIndex
6129 case 3:
6130 if wireType != 2 {
6131 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
6132 }
6133 var msglen int
6134 for shift := uint(0); ; shift += 7 {
6135 if shift >= 64 {
6136 return ErrIntOverflowGenerated
6137 }
6138 if iNdEx >= l {
6139 return io.ErrUnexpectedEOF
6140 }
6141 b := dAtA[iNdEx]
6142 iNdEx++
6143 msglen |= (int(b) & 0x7F) << shift
6144 if b < 0x80 {
6145 break
6146 }
6147 }
6148 if msglen < 0 {
6149 return ErrInvalidLengthGenerated
6150 }
6151 postIndex := iNdEx + msglen
6152 if postIndex > l {
6153 return io.ErrUnexpectedEOF
6154 }
6155 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6156 return err
6157 }
6158 iNdEx = postIndex
6159 case 4:
6160 if wireType != 2 {
6161 return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", wireType)
6162 }
6163 var msglen int
6164 for shift := uint(0); ; shift += 7 {
6165 if shift >= 64 {
6166 return ErrIntOverflowGenerated
6167 }
6168 if iNdEx >= l {
6169 return io.ErrUnexpectedEOF
6170 }
6171 b := dAtA[iNdEx]
6172 iNdEx++
6173 msglen |= (int(b) & 0x7F) << shift
6174 if b < 0x80 {
6175 break
6176 }
6177 }
6178 if msglen < 0 {
6179 return ErrInvalidLengthGenerated
6180 }
6181 postIndex := iNdEx + msglen
6182 if postIndex > l {
6183 return io.ErrUnexpectedEOF
6184 }
6185 m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, k8s_io_api_core_v1.PersistentVolumeClaim{})
6186 if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6187 return err
6188 }
6189 iNdEx = postIndex
6190 case 5:
6191 if wireType != 2 {
6192 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
6193 }
6194 var stringLen uint64
6195 for shift := uint(0); ; shift += 7 {
6196 if shift >= 64 {
6197 return ErrIntOverflowGenerated
6198 }
6199 if iNdEx >= l {
6200 return io.ErrUnexpectedEOF
6201 }
6202 b := dAtA[iNdEx]
6203 iNdEx++
6204 stringLen |= (uint64(b) & 0x7F) << shift
6205 if b < 0x80 {
6206 break
6207 }
6208 }
6209 intStringLen := int(stringLen)
6210 if intStringLen < 0 {
6211 return ErrInvalidLengthGenerated
6212 }
6213 postIndex := iNdEx + intStringLen
6214 if postIndex > l {
6215 return io.ErrUnexpectedEOF
6216 }
6217 m.ServiceName = string(dAtA[iNdEx:postIndex])
6218 iNdEx = postIndex
6219 case 6:
6220 if wireType != 2 {
6221 return fmt.Errorf("proto: wrong wireType = %d for field PodManagementPolicy", wireType)
6222 }
6223 var stringLen uint64
6224 for shift := uint(0); ; shift += 7 {
6225 if shift >= 64 {
6226 return ErrIntOverflowGenerated
6227 }
6228 if iNdEx >= l {
6229 return io.ErrUnexpectedEOF
6230 }
6231 b := dAtA[iNdEx]
6232 iNdEx++
6233 stringLen |= (uint64(b) & 0x7F) << shift
6234 if b < 0x80 {
6235 break
6236 }
6237 }
6238 intStringLen := int(stringLen)
6239 if intStringLen < 0 {
6240 return ErrInvalidLengthGenerated
6241 }
6242 postIndex := iNdEx + intStringLen
6243 if postIndex > l {
6244 return io.ErrUnexpectedEOF
6245 }
6246 m.PodManagementPolicy = PodManagementPolicyType(dAtA[iNdEx:postIndex])
6247 iNdEx = postIndex
6248 case 7:
6249 if wireType != 2 {
6250 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
6251 }
6252 var msglen int
6253 for shift := uint(0); ; shift += 7 {
6254 if shift >= 64 {
6255 return ErrIntOverflowGenerated
6256 }
6257 if iNdEx >= l {
6258 return io.ErrUnexpectedEOF
6259 }
6260 b := dAtA[iNdEx]
6261 iNdEx++
6262 msglen |= (int(b) & 0x7F) << shift
6263 if b < 0x80 {
6264 break
6265 }
6266 }
6267 if msglen < 0 {
6268 return ErrInvalidLengthGenerated
6269 }
6270 postIndex := iNdEx + msglen
6271 if postIndex > l {
6272 return io.ErrUnexpectedEOF
6273 }
6274 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6275 return err
6276 }
6277 iNdEx = postIndex
6278 case 8:
6279 if wireType != 0 {
6280 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
6281 }
6282 var v int32
6283 for shift := uint(0); ; shift += 7 {
6284 if shift >= 64 {
6285 return ErrIntOverflowGenerated
6286 }
6287 if iNdEx >= l {
6288 return io.ErrUnexpectedEOF
6289 }
6290 b := dAtA[iNdEx]
6291 iNdEx++
6292 v |= (int32(b) & 0x7F) << shift
6293 if b < 0x80 {
6294 break
6295 }
6296 }
6297 m.RevisionHistoryLimit = &v
6298 default:
6299 iNdEx = preIndex
6300 skippy, err := skipGenerated(dAtA[iNdEx:])
6301 if err != nil {
6302 return err
6303 }
6304 if skippy < 0 {
6305 return ErrInvalidLengthGenerated
6306 }
6307 if (iNdEx + skippy) > l {
6308 return io.ErrUnexpectedEOF
6309 }
6310 iNdEx += skippy
6311 }
6312 }
6313
6314 if iNdEx > l {
6315 return io.ErrUnexpectedEOF
6316 }
6317 return nil
6318}
6319func (m *StatefulSetStatus) Unmarshal(dAtA []byte) error {
6320 l := len(dAtA)
6321 iNdEx := 0
6322 for iNdEx < l {
6323 preIndex := iNdEx
6324 var wire uint64
6325 for shift := uint(0); ; shift += 7 {
6326 if shift >= 64 {
6327 return ErrIntOverflowGenerated
6328 }
6329 if iNdEx >= l {
6330 return io.ErrUnexpectedEOF
6331 }
6332 b := dAtA[iNdEx]
6333 iNdEx++
6334 wire |= (uint64(b) & 0x7F) << shift
6335 if b < 0x80 {
6336 break
6337 }
6338 }
6339 fieldNum := int32(wire >> 3)
6340 wireType := int(wire & 0x7)
6341 if wireType == 4 {
6342 return fmt.Errorf("proto: StatefulSetStatus: wiretype end group for non-group")
6343 }
6344 if fieldNum <= 0 {
6345 return fmt.Errorf("proto: StatefulSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6346 }
6347 switch fieldNum {
6348 case 1:
6349 if wireType != 0 {
6350 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6351 }
6352 m.ObservedGeneration = 0
6353 for shift := uint(0); ; shift += 7 {
6354 if shift >= 64 {
6355 return ErrIntOverflowGenerated
6356 }
6357 if iNdEx >= l {
6358 return io.ErrUnexpectedEOF
6359 }
6360 b := dAtA[iNdEx]
6361 iNdEx++
6362 m.ObservedGeneration |= (int64(b) & 0x7F) << shift
6363 if b < 0x80 {
6364 break
6365 }
6366 }
6367 case 2:
6368 if wireType != 0 {
6369 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6370 }
6371 m.Replicas = 0
6372 for shift := uint(0); ; shift += 7 {
6373 if shift >= 64 {
6374 return ErrIntOverflowGenerated
6375 }
6376 if iNdEx >= l {
6377 return io.ErrUnexpectedEOF
6378 }
6379 b := dAtA[iNdEx]
6380 iNdEx++
6381 m.Replicas |= (int32(b) & 0x7F) << shift
6382 if b < 0x80 {
6383 break
6384 }
6385 }
6386 case 3:
6387 if wireType != 0 {
6388 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6389 }
6390 m.ReadyReplicas = 0
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 m.ReadyReplicas |= (int32(b) & 0x7F) << shift
6401 if b < 0x80 {
6402 break
6403 }
6404 }
6405 case 4:
6406 if wireType != 0 {
6407 return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
6408 }
6409 m.CurrentReplicas = 0
6410 for shift := uint(0); ; shift += 7 {
6411 if shift >= 64 {
6412 return ErrIntOverflowGenerated
6413 }
6414 if iNdEx >= l {
6415 return io.ErrUnexpectedEOF
6416 }
6417 b := dAtA[iNdEx]
6418 iNdEx++
6419 m.CurrentReplicas |= (int32(b) & 0x7F) << shift
6420 if b < 0x80 {
6421 break
6422 }
6423 }
6424 case 5:
6425 if wireType != 0 {
6426 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
6427 }
6428 m.UpdatedReplicas = 0
6429 for shift := uint(0); ; shift += 7 {
6430 if shift >= 64 {
6431 return ErrIntOverflowGenerated
6432 }
6433 if iNdEx >= l {
6434 return io.ErrUnexpectedEOF
6435 }
6436 b := dAtA[iNdEx]
6437 iNdEx++
6438 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift
6439 if b < 0x80 {
6440 break
6441 }
6442 }
6443 case 6:
6444 if wireType != 2 {
6445 return fmt.Errorf("proto: wrong wireType = %d for field CurrentRevision", wireType)
6446 }
6447 var stringLen uint64
6448 for shift := uint(0); ; shift += 7 {
6449 if shift >= 64 {
6450 return ErrIntOverflowGenerated
6451 }
6452 if iNdEx >= l {
6453 return io.ErrUnexpectedEOF
6454 }
6455 b := dAtA[iNdEx]
6456 iNdEx++
6457 stringLen |= (uint64(b) & 0x7F) << shift
6458 if b < 0x80 {
6459 break
6460 }
6461 }
6462 intStringLen := int(stringLen)
6463 if intStringLen < 0 {
6464 return ErrInvalidLengthGenerated
6465 }
6466 postIndex := iNdEx + intStringLen
6467 if postIndex > l {
6468 return io.ErrUnexpectedEOF
6469 }
6470 m.CurrentRevision = string(dAtA[iNdEx:postIndex])
6471 iNdEx = postIndex
6472 case 7:
6473 if wireType != 2 {
6474 return fmt.Errorf("proto: wrong wireType = %d for field UpdateRevision", wireType)
6475 }
6476 var stringLen uint64
6477 for shift := uint(0); ; shift += 7 {
6478 if shift >= 64 {
6479 return ErrIntOverflowGenerated
6480 }
6481 if iNdEx >= l {
6482 return io.ErrUnexpectedEOF
6483 }
6484 b := dAtA[iNdEx]
6485 iNdEx++
6486 stringLen |= (uint64(b) & 0x7F) << shift
6487 if b < 0x80 {
6488 break
6489 }
6490 }
6491 intStringLen := int(stringLen)
6492 if intStringLen < 0 {
6493 return ErrInvalidLengthGenerated
6494 }
6495 postIndex := iNdEx + intStringLen
6496 if postIndex > l {
6497 return io.ErrUnexpectedEOF
6498 }
6499 m.UpdateRevision = string(dAtA[iNdEx:postIndex])
6500 iNdEx = postIndex
6501 case 9:
6502 if wireType != 0 {
6503 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
6504 }
6505 var v int32
6506 for shift := uint(0); ; shift += 7 {
6507 if shift >= 64 {
6508 return ErrIntOverflowGenerated
6509 }
6510 if iNdEx >= l {
6511 return io.ErrUnexpectedEOF
6512 }
6513 b := dAtA[iNdEx]
6514 iNdEx++
6515 v |= (int32(b) & 0x7F) << shift
6516 if b < 0x80 {
6517 break
6518 }
6519 }
6520 m.CollisionCount = &v
6521 case 10:
6522 if wireType != 2 {
6523 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
6524 }
6525 var msglen int
6526 for shift := uint(0); ; shift += 7 {
6527 if shift >= 64 {
6528 return ErrIntOverflowGenerated
6529 }
6530 if iNdEx >= l {
6531 return io.ErrUnexpectedEOF
6532 }
6533 b := dAtA[iNdEx]
6534 iNdEx++
6535 msglen |= (int(b) & 0x7F) << shift
6536 if b < 0x80 {
6537 break
6538 }
6539 }
6540 if msglen < 0 {
6541 return ErrInvalidLengthGenerated
6542 }
6543 postIndex := iNdEx + msglen
6544 if postIndex > l {
6545 return io.ErrUnexpectedEOF
6546 }
6547 m.Conditions = append(m.Conditions, StatefulSetCondition{})
6548 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6549 return err
6550 }
6551 iNdEx = postIndex
6552 default:
6553 iNdEx = preIndex
6554 skippy, err := skipGenerated(dAtA[iNdEx:])
6555 if err != nil {
6556 return err
6557 }
6558 if skippy < 0 {
6559 return ErrInvalidLengthGenerated
6560 }
6561 if (iNdEx + skippy) > l {
6562 return io.ErrUnexpectedEOF
6563 }
6564 iNdEx += skippy
6565 }
6566 }
6567
6568 if iNdEx > l {
6569 return io.ErrUnexpectedEOF
6570 }
6571 return nil
6572}
6573func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
6574 l := len(dAtA)
6575 iNdEx := 0
6576 for iNdEx < l {
6577 preIndex := iNdEx
6578 var wire uint64
6579 for shift := uint(0); ; shift += 7 {
6580 if shift >= 64 {
6581 return ErrIntOverflowGenerated
6582 }
6583 if iNdEx >= l {
6584 return io.ErrUnexpectedEOF
6585 }
6586 b := dAtA[iNdEx]
6587 iNdEx++
6588 wire |= (uint64(b) & 0x7F) << shift
6589 if b < 0x80 {
6590 break
6591 }
6592 }
6593 fieldNum := int32(wire >> 3)
6594 wireType := int(wire & 0x7)
6595 if wireType == 4 {
6596 return fmt.Errorf("proto: StatefulSetUpdateStrategy: wiretype end group for non-group")
6597 }
6598 if fieldNum <= 0 {
6599 return fmt.Errorf("proto: StatefulSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
6600 }
6601 switch fieldNum {
6602 case 1:
6603 if wireType != 2 {
6604 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6605 }
6606 var stringLen uint64
6607 for shift := uint(0); ; shift += 7 {
6608 if shift >= 64 {
6609 return ErrIntOverflowGenerated
6610 }
6611 if iNdEx >= l {
6612 return io.ErrUnexpectedEOF
6613 }
6614 b := dAtA[iNdEx]
6615 iNdEx++
6616 stringLen |= (uint64(b) & 0x7F) << shift
6617 if b < 0x80 {
6618 break
6619 }
6620 }
6621 intStringLen := int(stringLen)
6622 if intStringLen < 0 {
6623 return ErrInvalidLengthGenerated
6624 }
6625 postIndex := iNdEx + intStringLen
6626 if postIndex > l {
6627 return io.ErrUnexpectedEOF
6628 }
6629 m.Type = StatefulSetUpdateStrategyType(dAtA[iNdEx:postIndex])
6630 iNdEx = postIndex
6631 case 2:
6632 if wireType != 2 {
6633 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6634 }
6635 var msglen int
6636 for shift := uint(0); ; shift += 7 {
6637 if shift >= 64 {
6638 return ErrIntOverflowGenerated
6639 }
6640 if iNdEx >= l {
6641 return io.ErrUnexpectedEOF
6642 }
6643 b := dAtA[iNdEx]
6644 iNdEx++
6645 msglen |= (int(b) & 0x7F) << shift
6646 if b < 0x80 {
6647 break
6648 }
6649 }
6650 if msglen < 0 {
6651 return ErrInvalidLengthGenerated
6652 }
6653 postIndex := iNdEx + msglen
6654 if postIndex > l {
6655 return io.ErrUnexpectedEOF
6656 }
6657 if m.RollingUpdate == nil {
6658 m.RollingUpdate = &RollingUpdateStatefulSetStrategy{}
6659 }
6660 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6661 return err
6662 }
6663 iNdEx = postIndex
6664 default:
6665 iNdEx = preIndex
6666 skippy, err := skipGenerated(dAtA[iNdEx:])
6667 if err != nil {
6668 return err
6669 }
6670 if skippy < 0 {
6671 return ErrInvalidLengthGenerated
6672 }
6673 if (iNdEx + skippy) > l {
6674 return io.ErrUnexpectedEOF
6675 }
6676 iNdEx += skippy
6677 }
6678 }
6679
6680 if iNdEx > l {
6681 return io.ErrUnexpectedEOF
6682 }
6683 return nil
6684}
6685func skipGenerated(dAtA []byte) (n int, err error) {
6686 l := len(dAtA)
6687 iNdEx := 0
6688 for iNdEx < l {
6689 var wire uint64
6690 for shift := uint(0); ; shift += 7 {
6691 if shift >= 64 {
6692 return 0, ErrIntOverflowGenerated
6693 }
6694 if iNdEx >= l {
6695 return 0, io.ErrUnexpectedEOF
6696 }
6697 b := dAtA[iNdEx]
6698 iNdEx++
6699 wire |= (uint64(b) & 0x7F) << shift
6700 if b < 0x80 {
6701 break
6702 }
6703 }
6704 wireType := int(wire & 0x7)
6705 switch wireType {
6706 case 0:
6707 for shift := uint(0); ; shift += 7 {
6708 if shift >= 64 {
6709 return 0, ErrIntOverflowGenerated
6710 }
6711 if iNdEx >= l {
6712 return 0, io.ErrUnexpectedEOF
6713 }
6714 iNdEx++
6715 if dAtA[iNdEx-1] < 0x80 {
6716 break
6717 }
6718 }
6719 return iNdEx, nil
6720 case 1:
6721 iNdEx += 8
6722 return iNdEx, nil
6723 case 2:
6724 var length int
6725 for shift := uint(0); ; shift += 7 {
6726 if shift >= 64 {
6727 return 0, ErrIntOverflowGenerated
6728 }
6729 if iNdEx >= l {
6730 return 0, io.ErrUnexpectedEOF
6731 }
6732 b := dAtA[iNdEx]
6733 iNdEx++
6734 length |= (int(b) & 0x7F) << shift
6735 if b < 0x80 {
6736 break
6737 }
6738 }
6739 iNdEx += length
6740 if length < 0 {
6741 return 0, ErrInvalidLengthGenerated
6742 }
6743 return iNdEx, nil
6744 case 3:
6745 for {
6746 var innerWire uint64
6747 var start int = iNdEx
6748 for shift := uint(0); ; shift += 7 {
6749 if shift >= 64 {
6750 return 0, ErrIntOverflowGenerated
6751 }
6752 if iNdEx >= l {
6753 return 0, io.ErrUnexpectedEOF
6754 }
6755 b := dAtA[iNdEx]
6756 iNdEx++
6757 innerWire |= (uint64(b) & 0x7F) << shift
6758 if b < 0x80 {
6759 break
6760 }
6761 }
6762 innerWireType := int(innerWire & 0x7)
6763 if innerWireType == 4 {
6764 break
6765 }
6766 next, err := skipGenerated(dAtA[start:])
6767 if err != nil {
6768 return 0, err
6769 }
6770 iNdEx = start + next
6771 }
6772 return iNdEx, nil
6773 case 4:
6774 return iNdEx, nil
6775 case 5:
6776 iNdEx += 4
6777 return iNdEx, nil
6778 default:
6779 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
6780 }
6781 }
6782 panic("unreachable")
6783}
6784
6785var (
6786 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
6787 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
6788)
6789
6790func init() {
6791 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/apps/v1/generated.proto", fileDescriptorGenerated)
6792}
6793
6794var fileDescriptorGenerated = []byte{
6795 // 2037 bytes of a gzipped FileDescriptorProto
6796 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x24, 0x47,
6797 0x1d, 0x75, 0xcf, 0x87, 0x3d, 0x2e, 0xaf, 0xed, 0xdd, 0xb2, 0xb1, 0x27, 0xbb, 0x64, 0x66, 0x19,
6798 0x60, 0xe3, 0x64, 0xb3, 0x3d, 0xec, 0x66, 0x13, 0xa1, 0x2c, 0x02, 0x79, 0xc6, 0x21, 0x84, 0x78,
6799 0x6c, 0x53, 0x5e, 0xef, 0x61, 0x09, 0x12, 0xe5, 0xe9, 0xda, 0x71, 0xc7, 0xfd, 0xa5, 0xee, 0xea,
6800 0x61, 0x47, 0x5c, 0x10, 0x12, 0x9c, 0x38, 0xf0, 0x9f, 0x20, 0x84, 0xe0, 0x86, 0x22, 0xc4, 0x65,
6801 0x2f, 0x48, 0x11, 0x17, 0x72, 0xb2, 0xd8, 0xc9, 0x09, 0xa1, 0x1c, 0xb9, 0xe4, 0x02, 0xaa, 0xea,
6802 0xea, 0xef, 0x6a, 0xcf, 0xd8, 0x9b, 0x75, 0x50, 0x94, 0x9b, 0xa7, 0xea, 0xfd, 0x5e, 0xff, 0xaa,
6803 0xea, 0x57, 0xf5, 0x5e, 0x57, 0x1b, 0xdc, 0x3b, 0xfe, 0xb6, 0xa7, 0xea, 0x76, 0xfb, 0xd8, 0x3f,
6804 0x24, 0xae, 0x45, 0x28, 0xf1, 0xda, 0x43, 0x62, 0x69, 0xb6, 0xdb, 0x16, 0x1d, 0xd8, 0xd1, 0xdb,
6805 0xd8, 0x71, 0xbc, 0xf6, 0xf0, 0x76, 0x7b, 0x40, 0x2c, 0xe2, 0x62, 0x4a, 0x34, 0xd5, 0x71, 0x6d,
6806 0x6a, 0x43, 0x18, 0x60, 0x54, 0xec, 0xe8, 0x2a, 0xc3, 0xa8, 0xc3, 0xdb, 0x57, 0x6f, 0x0d, 0x74,
6807 0x7a, 0xe4, 0x1f, 0xaa, 0x7d, 0xdb, 0x6c, 0x0f, 0xec, 0x81, 0xdd, 0xe6, 0xd0, 0x43, 0xff, 0x11,
6808 0xff, 0xc5, 0x7f, 0xf0, 0xbf, 0x02, 0x8a, 0xab, 0xad, 0xc4, 0x63, 0xfa, 0xb6, 0x4b, 0x24, 0x8f,
6809 0xb9, 0x7a, 0x37, 0xc6, 0x98, 0xb8, 0x7f, 0xa4, 0x5b, 0xc4, 0x1d, 0xb5, 0x9d, 0xe3, 0x01, 0x6b,
6810 0xf0, 0xda, 0x26, 0xa1, 0x58, 0x16, 0xd5, 0x2e, 0x8a, 0x72, 0x7d, 0x8b, 0xea, 0x26, 0xc9, 0x05,
6811 0xbc, 0x31, 0x29, 0xc0, 0xeb, 0x1f, 0x11, 0x13, 0xe7, 0xe2, 0x5e, 0x2b, 0x8a, 0xf3, 0xa9, 0x6e,
6812 0xb4, 0x75, 0x8b, 0x7a, 0xd4, 0xcd, 0x06, 0xb5, 0xfe, 0xa3, 0x00, 0xd8, 0xb5, 0x2d, 0xea, 0xda,
6813 0x86, 0x41, 0x5c, 0x44, 0x86, 0xba, 0xa7, 0xdb, 0x16, 0xfc, 0x29, 0xa8, 0xb1, 0xf1, 0x68, 0x98,
6814 0xe2, 0xba, 0x72, 0x5d, 0xd9, 0x58, 0xb8, 0xf3, 0x2d, 0x35, 0x9e, 0xe4, 0x88, 0x5e, 0x75, 0x8e,
6815 0x07, 0xac, 0xc1, 0x53, 0x19, 0x5a, 0x1d, 0xde, 0x56, 0x77, 0x0f, 0xdf, 0x27, 0x7d, 0xda, 0x23,
6816 0x14, 0x77, 0xe0, 0x93, 0x93, 0xe6, 0xcc, 0xf8, 0xa4, 0x09, 0xe2, 0x36, 0x14, 0xb1, 0xc2, 0x5d,
6817 0x50, 0xe1, 0xec, 0x25, 0xce, 0x7e, 0xab, 0x90, 0x5d, 0x0c, 0x5a, 0x45, 0xf8, 0x67, 0x6f, 0x3d,
6818 0xa6, 0xc4, 0x62, 0xe9, 0x75, 0x2e, 0x09, 0xea, 0xca, 0x16, 0xa6, 0x18, 0x71, 0x22, 0xf8, 0x2a,
6819 0xa8, 0xb9, 0x22, 0xfd, 0x7a, 0xf9, 0xba, 0xb2, 0x51, 0xee, 0x5c, 0x16, 0xa8, 0x5a, 0x38, 0x2c,
6820 0x14, 0x21, 0x5a, 0x7f, 0x55, 0xc0, 0x5a, 0x7e, 0xdc, 0xdb, 0xba, 0x47, 0xe1, 0x7b, 0xb9, 0xb1,
6821 0xab, 0xd3, 0x8d, 0x9d, 0x45, 0xf3, 0x91, 0x47, 0x0f, 0x0e, 0x5b, 0x12, 0xe3, 0x7e, 0x17, 0x54,
6822 0x75, 0x4a, 0x4c, 0xaf, 0x5e, 0xba, 0x5e, 0xde, 0x58, 0xb8, 0x73, 0x43, 0xcd, 0xd7, 0xae, 0x9a,
6823 0x4f, 0xac, 0xb3, 0x28, 0x28, 0xab, 0xef, 0xb0, 0x60, 0x14, 0x70, 0xb4, 0xfe, 0xab, 0x80, 0xf9,
6824 0x2d, 0x4c, 0x4c, 0xdb, 0xda, 0x27, 0xf4, 0x02, 0x16, 0xad, 0x0b, 0x2a, 0x9e, 0x43, 0xfa, 0x62,
6825 0xd1, 0xbe, 0x26, 0xcb, 0x3d, 0x4a, 0x67, 0xdf, 0x21, 0xfd, 0x78, 0xa1, 0xd8, 0x2f, 0xc4, 0x83,
6826 0xe1, 0xbb, 0x60, 0xd6, 0xa3, 0x98, 0xfa, 0x1e, 0x5f, 0xa6, 0x85, 0x3b, 0x5f, 0x3f, 0x9d, 0x86,
6827 0x43, 0x3b, 0x4b, 0x82, 0x68, 0x36, 0xf8, 0x8d, 0x04, 0x45, 0xeb, 0x5f, 0x25, 0x00, 0x23, 0x6c,
6828 0xd7, 0xb6, 0x34, 0x9d, 0xb2, 0xfa, 0x7d, 0x13, 0x54, 0xe8, 0xc8, 0x21, 0x7c, 0x1a, 0xe6, 0x3b,
6829 0x37, 0xc2, 0x2c, 0xee, 0x8f, 0x1c, 0xf2, 0xe9, 0x49, 0x73, 0x2d, 0x1f, 0xc1, 0x7a, 0x10, 0x8f,
6830 0x81, 0xdb, 0x51, 0x7e, 0x25, 0x1e, 0x7d, 0x37, 0xfd, 0xe8, 0x4f, 0x4f, 0x9a, 0x92, 0xc3, 0x42,
6831 0x8d, 0x98, 0xd2, 0x09, 0xc2, 0x21, 0x80, 0x06, 0xf6, 0xe8, 0x7d, 0x17, 0x5b, 0x5e, 0xf0, 0x24,
6832 0xdd, 0x24, 0x62, 0xe4, 0xaf, 0x4c, 0xb7, 0x3c, 0x2c, 0xa2, 0x73, 0x55, 0x64, 0x01, 0xb7, 0x73,
6833 0x6c, 0x48, 0xf2, 0x04, 0x78, 0x03, 0xcc, 0xba, 0x04, 0x7b, 0xb6, 0x55, 0xaf, 0xf0, 0x51, 0x44,
6834 0x13, 0x88, 0x78, 0x2b, 0x12, 0xbd, 0xf0, 0x65, 0x30, 0x67, 0x12, 0xcf, 0xc3, 0x03, 0x52, 0xaf,
6835 0x72, 0xe0, 0xb2, 0x00, 0xce, 0xf5, 0x82, 0x66, 0x14, 0xf6, 0xb7, 0x7e, 0xaf, 0x80, 0xc5, 0x68,
6836 0xe6, 0x2e, 0x60, 0xab, 0x74, 0xd2, 0x5b, 0xe5, 0xc5, 0x53, 0xeb, 0xa4, 0x60, 0x87, 0x7c, 0x50,
6837 0x4e, 0xe4, 0xcc, 0x8a, 0x10, 0xfe, 0x04, 0xd4, 0x3c, 0x62, 0x90, 0x3e, 0xb5, 0x5d, 0x91, 0xf3,
6838 0x6b, 0x53, 0xe6, 0x8c, 0x0f, 0x89, 0xb1, 0x2f, 0x42, 0x3b, 0x97, 0x58, 0xd2, 0xe1, 0x2f, 0x14,
6839 0x51, 0xc2, 0x1f, 0x81, 0x1a, 0x25, 0xa6, 0x63, 0x60, 0x4a, 0xc4, 0x36, 0x49, 0xd5, 0x37, 0x2b,
6840 0x17, 0x46, 0xb6, 0x67, 0x6b, 0xf7, 0x05, 0x8c, 0x6f, 0x94, 0x68, 0x1e, 0xc2, 0x56, 0x14, 0xd1,
6841 0xc0, 0x63, 0xb0, 0xe4, 0x3b, 0x1a, 0x43, 0x52, 0x76, 0x74, 0x0f, 0x46, 0xa2, 0x7c, 0x6e, 0x9e,
6842 0x3a, 0x21, 0x07, 0xa9, 0x90, 0xce, 0x9a, 0x78, 0xc0, 0x52, 0xba, 0x1d, 0x65, 0xa8, 0xe1, 0x26,
6843 0x58, 0x36, 0x75, 0x0b, 0x11, 0xac, 0x8d, 0xf6, 0x49, 0xdf, 0xb6, 0x34, 0x8f, 0x17, 0x50, 0xb5,
6844 0xb3, 0x2e, 0x08, 0x96, 0x7b, 0xe9, 0x6e, 0x94, 0xc5, 0xc3, 0x6d, 0xb0, 0x1a, 0x9e, 0xb3, 0x3f,
6845 0xd0, 0x3d, 0x6a, 0xbb, 0xa3, 0x6d, 0xdd, 0xd4, 0x69, 0x7d, 0x96, 0xf3, 0xd4, 0xc7, 0x27, 0xcd,
6846 0x55, 0x24, 0xe9, 0x47, 0xd2, 0xa8, 0xd6, 0x6f, 0x66, 0xc1, 0x72, 0xe6, 0x34, 0x80, 0x0f, 0xc0,
6847 0x5a, 0xdf, 0x77, 0x5d, 0x62, 0xd1, 0x1d, 0xdf, 0x3c, 0x24, 0xee, 0x7e, 0xff, 0x88, 0x68, 0xbe,
6848 0x41, 0x34, 0xbe, 0xa2, 0xd5, 0x4e, 0x43, 0xe4, 0xba, 0xd6, 0x95, 0xa2, 0x50, 0x41, 0x34, 0xfc,
6849 0x21, 0x80, 0x16, 0x6f, 0xea, 0xe9, 0x9e, 0x17, 0x71, 0x96, 0x38, 0x67, 0xb4, 0x01, 0x77, 0x72,
6850 0x08, 0x24, 0x89, 0x62, 0x39, 0x6a, 0xc4, 0xd3, 0x5d, 0xa2, 0x65, 0x73, 0x2c, 0xa7, 0x73, 0xdc,
6851 0x92, 0xa2, 0x50, 0x41, 0x34, 0x7c, 0x1d, 0x2c, 0x04, 0x4f, 0xe3, 0x73, 0x2e, 0x16, 0x67, 0x45,
6852 0x90, 0x2d, 0xec, 0xc4, 0x5d, 0x28, 0x89, 0x63, 0x43, 0xb3, 0x0f, 0x3d, 0xe2, 0x0e, 0x89, 0xf6,
6853 0x76, 0xe0, 0x01, 0x98, 0x50, 0x56, 0xb9, 0x50, 0x46, 0x43, 0xdb, 0xcd, 0x21, 0x90, 0x24, 0x8a,
6854 0x0d, 0x2d, 0xa8, 0x9a, 0xdc, 0xd0, 0x66, 0xd3, 0x43, 0x3b, 0x90, 0xa2, 0x50, 0x41, 0x34, 0xab,
6855 0xbd, 0x20, 0xe5, 0xcd, 0x21, 0xd6, 0x0d, 0x7c, 0x68, 0x90, 0xfa, 0x5c, 0xba, 0xf6, 0x76, 0xd2,
6856 0xdd, 0x28, 0x8b, 0x87, 0x6f, 0x83, 0x2b, 0x41, 0xd3, 0x81, 0x85, 0x23, 0x92, 0x1a, 0x27, 0x79,
6857 0x41, 0x90, 0x5c, 0xd9, 0xc9, 0x02, 0x50, 0x3e, 0x06, 0xbe, 0x09, 0x96, 0xfa, 0xb6, 0x61, 0xf0,
6858 0x7a, 0xec, 0xda, 0xbe, 0x45, 0xeb, 0xf3, 0x9c, 0x05, 0xb2, 0x3d, 0xd4, 0x4d, 0xf5, 0xa0, 0x0c,
6859 0x12, 0x3e, 0x04, 0xa0, 0x1f, 0xca, 0x81, 0x57, 0x07, 0xc5, 0x42, 0x9f, 0xd7, 0xa1, 0x58, 0x80,
6860 0xa3, 0x26, 0x0f, 0x25, 0xd8, 0x5a, 0x1f, 0x28, 0x60, 0xbd, 0x60, 0x8f, 0xc3, 0xef, 0xa5, 0x54,
6861 0xef, 0x66, 0x46, 0xf5, 0xae, 0x15, 0x84, 0x25, 0xa4, 0xaf, 0x0f, 0x16, 0x99, 0xef, 0xd0, 0xad,
6862 0x41, 0x00, 0x11, 0x27, 0xd8, 0x2b, 0xb2, 0xdc, 0x51, 0x12, 0x18, 0x1f, 0xc3, 0x57, 0xc6, 0x27,
6863 0xcd, 0xc5, 0x54, 0x1f, 0x4a, 0x73, 0xb6, 0x7e, 0x59, 0x02, 0x60, 0x8b, 0x38, 0x86, 0x3d, 0x32,
6864 0x89, 0x75, 0x11, 0xae, 0x65, 0x2b, 0xe5, 0x5a, 0x5a, 0xd2, 0x85, 0x88, 0xf2, 0x29, 0xb4, 0x2d,
6865 0xdb, 0x19, 0xdb, 0xf2, 0x8d, 0x09, 0x3c, 0xa7, 0xfb, 0x96, 0x7f, 0x94, 0xc1, 0x4a, 0x0c, 0x8e,
6866 0x8d, 0xcb, 0xbd, 0xd4, 0x12, 0xbe, 0x94, 0x59, 0xc2, 0x75, 0x49, 0xc8, 0x73, 0x73, 0x2e, 0x9f,
6867 0xbd, 0x83, 0x80, 0xef, 0x83, 0x25, 0x66, 0x55, 0x82, 0x42, 0xe0, 0x46, 0x68, 0xf6, 0xcc, 0x46,
6868 0x28, 0x12, 0xb2, 0xed, 0x14, 0x13, 0xca, 0x30, 0x17, 0x18, 0xaf, 0xb9, 0xe7, 0x6d, 0xbc, 0x5a,
6869 0x7f, 0x50, 0xc0, 0x52, 0xbc, 0x4c, 0x17, 0x60, 0x93, 0xba, 0x69, 0x9b, 0xd4, 0x38, 0xbd, 0x2e,
6870 0x0b, 0x7c, 0xd2, 0xdf, 0x2b, 0xc9, 0xac, 0xb9, 0x51, 0xda, 0x60, 0x2f, 0x54, 0x8e, 0xa1, 0xf7,
6871 0xb1, 0x27, 0x64, 0xf5, 0x52, 0xf0, 0x32, 0x15, 0xb4, 0xa1, 0xa8, 0x37, 0x65, 0xa9, 0x4a, 0xcf,
6872 0xd7, 0x52, 0x95, 0x3f, 0x1b, 0x4b, 0x75, 0x1f, 0xd4, 0xbc, 0xd0, 0x4c, 0x55, 0x38, 0xe5, 0x8d,
6873 0x49, 0xdb, 0x59, 0xf8, 0xa8, 0x88, 0x35, 0x72, 0x50, 0x11, 0x93, 0xcc, 0x3b, 0x55, 0x3f, 0x4f,
6874 0xef, 0xc4, 0xb6, 0xb0, 0x83, 0x7d, 0x8f, 0x68, 0xbc, 0xee, 0x6b, 0xf1, 0x16, 0xde, 0xe3, 0xad,
6875 0x48, 0xf4, 0xc2, 0x03, 0xb0, 0xee, 0xb8, 0xf6, 0xc0, 0x25, 0x9e, 0xb7, 0x45, 0xb0, 0x66, 0xe8,
6876 0x16, 0x09, 0x07, 0x10, 0xa8, 0xde, 0xb5, 0xf1, 0x49, 0x73, 0x7d, 0x4f, 0x0e, 0x41, 0x45, 0xb1,
6877 0xad, 0x3f, 0x57, 0xc0, 0xe5, 0xec, 0x89, 0x58, 0x60, 0x44, 0x94, 0x73, 0x19, 0x91, 0x57, 0x13,
6878 0x25, 0x1a, 0xb8, 0xb4, 0xc4, 0x3b, 0x7f, 0xae, 0x4c, 0x37, 0xc1, 0xb2, 0x30, 0x1e, 0x61, 0xa7,
6879 0xb0, 0x62, 0xd1, 0xf2, 0x1c, 0xa4, 0xbb, 0x51, 0x16, 0xcf, 0xec, 0x45, 0xec, 0x1a, 0x42, 0x92,
6880 0x4a, 0xda, 0x5e, 0x6c, 0x66, 0x01, 0x28, 0x1f, 0x03, 0x7b, 0x60, 0xc5, 0xb7, 0xf2, 0x54, 0x41,
6881 0xb9, 0x5c, 0x13, 0x54, 0x2b, 0x07, 0x79, 0x08, 0x92, 0xc5, 0xc1, 0x1f, 0xa7, 0x1c, 0xc7, 0x2c,
6882 0x3f, 0x08, 0x5e, 0x3a, 0xbd, 0xa2, 0xa7, 0xb6, 0x1c, 0xf0, 0x1e, 0x58, 0x74, 0xb9, 0xa1, 0x0c,
6883 0xb3, 0x0c, 0x4c, 0xd9, 0x57, 0x44, 0xd8, 0x22, 0x4a, 0x76, 0xa2, 0x34, 0x56, 0xe2, 0xa3, 0x6a,
6884 0xd3, 0xfa, 0xa8, 0xd6, 0x9f, 0x14, 0x00, 0xf3, 0x5b, 0x70, 0xe2, 0xcb, 0x7d, 0x2e, 0x22, 0x21,
6885 0x91, 0x9a, 0xdc, 0xe1, 0xdc, 0x9c, 0xec, 0x70, 0xe2, 0x13, 0x74, 0x3a, 0x8b, 0x23, 0x66, 0xe0,
6886 0x62, 0x2e, 0x66, 0xa6, 0xb0, 0x38, 0x71, 0x3e, 0xcf, 0x66, 0x71, 0x12, 0x3c, 0xa7, 0x5b, 0x9c,
6887 0x7f, 0x97, 0xc0, 0x4a, 0x0c, 0x9e, 0xda, 0xe2, 0x48, 0x42, 0xbe, 0xbc, 0x9c, 0x99, 0x7c, 0x39,
6888 0xc3, 0x6c, 0x47, 0x3c, 0x75, 0xff, 0x27, 0xb6, 0x23, 0x4e, 0xa8, 0xc0, 0x76, 0xfc, 0xae, 0x94,
6889 0xcc, 0xfa, 0x0b, 0x6f, 0x3b, 0x9e, 0xfd, 0x72, 0xa5, 0xf5, 0x97, 0x32, 0xb8, 0x9c, 0xdd, 0x82,
6890 0x29, 0x1d, 0x54, 0x26, 0xea, 0xe0, 0x1e, 0x58, 0x7d, 0xe4, 0x1b, 0xc6, 0x88, 0x4f, 0x43, 0x42,
6891 0x0c, 0x03, 0x05, 0xfd, 0xaa, 0x88, 0x5c, 0xfd, 0xbe, 0x04, 0x83, 0xa4, 0x91, 0x05, 0x9a, 0x5e,
6892 0x3e, 0x97, 0xa6, 0xe7, 0xd4, 0xa6, 0x72, 0x06, 0xb5, 0x91, 0xea, 0x73, 0xf5, 0x1c, 0xfa, 0x3c,
6893 0xb5, 0xa0, 0x4a, 0x8e, 0xab, 0x89, 0xef, 0xf0, 0xbf, 0x56, 0xc0, 0x9a, 0xfc, 0xf5, 0x19, 0x1a,
6894 0x60, 0xc9, 0xc4, 0x8f, 0x93, 0x97, 0x17, 0x93, 0x04, 0xc3, 0xa7, 0xba, 0xa1, 0x06, 0x5f, 0x77,
6895 0xd4, 0x77, 0x2c, 0xba, 0xeb, 0xee, 0x53, 0x57, 0xb7, 0x06, 0x81, 0xc0, 0xf6, 0x52, 0x5c, 0x28,
6896 0xc3, 0xdd, 0xfa, 0x58, 0x01, 0xeb, 0x05, 0x2a, 0x77, 0xb1, 0x99, 0xc0, 0x87, 0xa0, 0x66, 0xe2,
6897 0xc7, 0xfb, 0xbe, 0x3b, 0x08, 0x25, 0xf9, 0xec, 0xcf, 0xe1, 0x1b, 0xb9, 0x27, 0x58, 0x50, 0xc4,
6898 0xd7, 0xda, 0x05, 0xd7, 0x53, 0x83, 0x64, 0x9b, 0x86, 0x3c, 0xf2, 0x0d, 0xbe, 0x7f, 0x84, 0xa7,
6899 0xb8, 0x09, 0xe6, 0x1d, 0xec, 0x52, 0x3d, 0x32, 0xa3, 0xd5, 0xce, 0xe2, 0xf8, 0xa4, 0x39, 0xbf,
6900 0x17, 0x36, 0xa2, 0xb8, 0xbf, 0xf5, 0xab, 0x12, 0x58, 0x48, 0x90, 0x5c, 0x80, 0xbe, 0xbf, 0x95,
6901 0xd2, 0x77, 0xe9, 0x17, 0x93, 0xe4, 0xa8, 0x8a, 0x04, 0xbe, 0x97, 0x11, 0xf8, 0x6f, 0x4e, 0x22,
6902 0x3a, 0x5d, 0xe1, 0x3f, 0x29, 0x81, 0xd5, 0x04, 0x3a, 0x96, 0xf8, 0xef, 0xa4, 0x24, 0x7e, 0x23,
6903 0x23, 0xf1, 0x75, 0x59, 0xcc, 0x97, 0x1a, 0x3f, 0x59, 0xe3, 0xff, 0xa8, 0x80, 0xe5, 0xc4, 0xdc,
6904 0x5d, 0x80, 0xc8, 0x6f, 0xa5, 0x45, 0xbe, 0x39, 0xa1, 0x5e, 0x0a, 0x54, 0xfe, 0x49, 0x35, 0x95,
6905 0xf7, 0x17, 0x5e, 0xe6, 0x7f, 0x0e, 0x56, 0x87, 0xb6, 0xe1, 0x9b, 0xa4, 0x6b, 0x60, 0xdd, 0x0c,
6906 0x01, 0x4c, 0xc9, 0xd8, 0x24, 0xbe, 0x2c, 0xa5, 0x27, 0xae, 0xa7, 0x7b, 0x94, 0x58, 0xf4, 0x41,
6907 0x1c, 0x19, 0x6b, 0xf1, 0x03, 0x09, 0x1d, 0x92, 0x3e, 0x04, 0xbe, 0x0e, 0x16, 0x98, 0xa6, 0xea,
6908 0x7d, 0xb2, 0x83, 0xcd, 0xb0, 0xa6, 0xa2, 0xef, 0x03, 0xfb, 0x71, 0x17, 0x4a, 0xe2, 0xe0, 0x11,
6909 0x58, 0x71, 0x6c, 0xad, 0x87, 0x2d, 0x3c, 0x20, 0xec, 0xfc, 0xdf, 0xb3, 0x0d, 0xbd, 0x3f, 0xe2,
6910 0xf7, 0x0e, 0xf3, 0x9d, 0x37, 0xc2, 0x17, 0xd2, 0xbd, 0x3c, 0x84, 0x79, 0x76, 0x49, 0x33, 0xdf,
6911 0xcf, 0x32, 0x4a, 0x68, 0xe6, 0x3e, 0x67, 0xcd, 0xe5, 0xfe, 0x07, 0x40, 0x56, 0x5c, 0xe7, 0xfc,
6912 0xa0, 0x55, 0x74, 0xa3, 0x52, 0x3b, 0xd7, 0xd7, 0xa8, 0x4f, 0x2a, 0xe0, 0x4a, 0xee, 0x80, 0xfc,
6913 0x1c, 0xef, 0x34, 0x72, 0x6e, 0xa9, 0x7c, 0x06, 0xb7, 0xb4, 0x09, 0x96, 0xc5, 0x87, 0xb0, 0x8c,
6914 0xd9, 0x8a, 0xec, 0x68, 0x37, 0xdd, 0x8d, 0xb2, 0x78, 0xd9, 0x9d, 0x4a, 0xf5, 0x8c, 0x77, 0x2a,
6915 0xc9, 0x2c, 0xc4, 0xff, 0x6f, 0x04, 0x55, 0x97, 0xcf, 0x42, 0xfc, 0x1b, 0x47, 0x16, 0x0f, 0xbf,
6916 0x1b, 0x96, 0x54, 0xc4, 0x30, 0xc7, 0x19, 0x32, 0x35, 0x12, 0x11, 0x64, 0xd0, 0xcf, 0xf4, 0xb1,
6917 0xe7, 0x3d, 0xc9, 0xc7, 0x9e, 0x8d, 0x09, 0xa5, 0x3c, 0xbd, 0x55, 0xfc, 0x9b, 0x02, 0x5e, 0x28,
6918 0xdc, 0x03, 0x70, 0x33, 0xa5, 0xb3, 0xb7, 0x32, 0x3a, 0xfb, 0x62, 0x61, 0x60, 0x42, 0x6c, 0x4d,
6919 0xf9, 0x85, 0xc8, 0xdd, 0x89, 0x17, 0x22, 0x12, 0x17, 0x35, 0xf9, 0x66, 0xa4, 0xb3, 0xf1, 0xe4,
6920 0x69, 0x63, 0xe6, 0xc3, 0xa7, 0x8d, 0x99, 0x8f, 0x9e, 0x36, 0x66, 0x7e, 0x31, 0x6e, 0x28, 0x4f,
6921 0xc6, 0x0d, 0xe5, 0xc3, 0x71, 0x43, 0xf9, 0x68, 0xdc, 0x50, 0xfe, 0x39, 0x6e, 0x28, 0xbf, 0xfd,
6922 0xb8, 0x31, 0xf3, 0xb0, 0x34, 0xbc, 0xfd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x6b, 0x01,
6923 0x7b, 0x12, 0x26, 0x00, 0x00,
6924}