blob: 2ca3fa6524fb22f6b897745bc39f4d181e2508e2 [file] [log] [blame]
Scott Bakere7144bc2019-10-01 14:16:47 -07001/*
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/admissionregistration/v1beta1/generated.proto
19
20/*
21 Package v1beta1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto
25
26 It has these top-level messages:
27 MutatingWebhookConfiguration
28 MutatingWebhookConfigurationList
29 Rule
30 RuleWithOperations
31 ServiceReference
32 ValidatingWebhookConfiguration
33 ValidatingWebhookConfigurationList
34 Webhook
35 WebhookClientConfig
36*/
37package v1beta1
38
39import proto "github.com/gogo/protobuf/proto"
40import fmt "fmt"
41import math "math"
42
43import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
44
45import strings "strings"
46import reflect "reflect"
47
48import io "io"
49
50// Reference imports to suppress errors if they are not otherwise used.
51var _ = proto.Marshal
52var _ = fmt.Errorf
53var _ = math.Inf
54
55// This is a compile-time assertion to ensure that this generated file
56// is compatible with the proto package it is being compiled against.
57// A compilation error at this line likely means your copy of the
58// proto package needs to be updated.
59const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
60
61func (m *MutatingWebhookConfiguration) Reset() { *m = MutatingWebhookConfiguration{} }
62func (*MutatingWebhookConfiguration) ProtoMessage() {}
63func (*MutatingWebhookConfiguration) Descriptor() ([]byte, []int) {
64 return fileDescriptorGenerated, []int{0}
65}
66
67func (m *MutatingWebhookConfigurationList) Reset() { *m = MutatingWebhookConfigurationList{} }
68func (*MutatingWebhookConfigurationList) ProtoMessage() {}
69func (*MutatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
70 return fileDescriptorGenerated, []int{1}
71}
72
73func (m *Rule) Reset() { *m = Rule{} }
74func (*Rule) ProtoMessage() {}
75func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
76
77func (m *RuleWithOperations) Reset() { *m = RuleWithOperations{} }
78func (*RuleWithOperations) ProtoMessage() {}
79func (*RuleWithOperations) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
80
81func (m *ServiceReference) Reset() { *m = ServiceReference{} }
82func (*ServiceReference) ProtoMessage() {}
83func (*ServiceReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
84
85func (m *ValidatingWebhookConfiguration) Reset() { *m = ValidatingWebhookConfiguration{} }
86func (*ValidatingWebhookConfiguration) ProtoMessage() {}
87func (*ValidatingWebhookConfiguration) Descriptor() ([]byte, []int) {
88 return fileDescriptorGenerated, []int{5}
89}
90
91func (m *ValidatingWebhookConfigurationList) Reset() { *m = ValidatingWebhookConfigurationList{} }
92func (*ValidatingWebhookConfigurationList) ProtoMessage() {}
93func (*ValidatingWebhookConfigurationList) Descriptor() ([]byte, []int) {
94 return fileDescriptorGenerated, []int{6}
95}
96
97func (m *Webhook) Reset() { *m = Webhook{} }
98func (*Webhook) ProtoMessage() {}
99func (*Webhook) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
100
101func (m *WebhookClientConfig) Reset() { *m = WebhookClientConfig{} }
102func (*WebhookClientConfig) ProtoMessage() {}
103func (*WebhookClientConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
104
105func init() {
106 proto.RegisterType((*MutatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfiguration")
107 proto.RegisterType((*MutatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.MutatingWebhookConfigurationList")
108 proto.RegisterType((*Rule)(nil), "k8s.io.api.admissionregistration.v1beta1.Rule")
109 proto.RegisterType((*RuleWithOperations)(nil), "k8s.io.api.admissionregistration.v1beta1.RuleWithOperations")
110 proto.RegisterType((*ServiceReference)(nil), "k8s.io.api.admissionregistration.v1beta1.ServiceReference")
111 proto.RegisterType((*ValidatingWebhookConfiguration)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfiguration")
112 proto.RegisterType((*ValidatingWebhookConfigurationList)(nil), "k8s.io.api.admissionregistration.v1beta1.ValidatingWebhookConfigurationList")
113 proto.RegisterType((*Webhook)(nil), "k8s.io.api.admissionregistration.v1beta1.Webhook")
114 proto.RegisterType((*WebhookClientConfig)(nil), "k8s.io.api.admissionregistration.v1beta1.WebhookClientConfig")
115}
116func (m *MutatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
117 size := m.Size()
118 dAtA = make([]byte, size)
119 n, err := m.MarshalTo(dAtA)
120 if err != nil {
121 return nil, err
122 }
123 return dAtA[:n], nil
124}
125
126func (m *MutatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
127 var i int
128 _ = i
129 var l int
130 _ = l
131 dAtA[i] = 0xa
132 i++
133 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
134 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
135 if err != nil {
136 return 0, err
137 }
138 i += n1
139 if len(m.Webhooks) > 0 {
140 for _, msg := range m.Webhooks {
141 dAtA[i] = 0x12
142 i++
143 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
144 n, err := msg.MarshalTo(dAtA[i:])
145 if err != nil {
146 return 0, err
147 }
148 i += n
149 }
150 }
151 return i, nil
152}
153
154func (m *MutatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
155 size := m.Size()
156 dAtA = make([]byte, size)
157 n, err := m.MarshalTo(dAtA)
158 if err != nil {
159 return nil, err
160 }
161 return dAtA[:n], nil
162}
163
164func (m *MutatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
165 var i int
166 _ = i
167 var l int
168 _ = l
169 dAtA[i] = 0xa
170 i++
171 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
172 n2, err := m.ListMeta.MarshalTo(dAtA[i:])
173 if err != nil {
174 return 0, err
175 }
176 i += n2
177 if len(m.Items) > 0 {
178 for _, msg := range m.Items {
179 dAtA[i] = 0x12
180 i++
181 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
182 n, err := msg.MarshalTo(dAtA[i:])
183 if err != nil {
184 return 0, err
185 }
186 i += n
187 }
188 }
189 return i, nil
190}
191
192func (m *Rule) Marshal() (dAtA []byte, err error) {
193 size := m.Size()
194 dAtA = make([]byte, size)
195 n, err := m.MarshalTo(dAtA)
196 if err != nil {
197 return nil, err
198 }
199 return dAtA[:n], nil
200}
201
202func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
203 var i int
204 _ = i
205 var l int
206 _ = l
207 if len(m.APIGroups) > 0 {
208 for _, s := range m.APIGroups {
209 dAtA[i] = 0xa
210 i++
211 l = len(s)
212 for l >= 1<<7 {
213 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
214 l >>= 7
215 i++
216 }
217 dAtA[i] = uint8(l)
218 i++
219 i += copy(dAtA[i:], s)
220 }
221 }
222 if len(m.APIVersions) > 0 {
223 for _, s := range m.APIVersions {
224 dAtA[i] = 0x12
225 i++
226 l = len(s)
227 for l >= 1<<7 {
228 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
229 l >>= 7
230 i++
231 }
232 dAtA[i] = uint8(l)
233 i++
234 i += copy(dAtA[i:], s)
235 }
236 }
237 if len(m.Resources) > 0 {
238 for _, s := range m.Resources {
239 dAtA[i] = 0x1a
240 i++
241 l = len(s)
242 for l >= 1<<7 {
243 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
244 l >>= 7
245 i++
246 }
247 dAtA[i] = uint8(l)
248 i++
249 i += copy(dAtA[i:], s)
250 }
251 }
252 return i, nil
253}
254
255func (m *RuleWithOperations) Marshal() (dAtA []byte, err error) {
256 size := m.Size()
257 dAtA = make([]byte, size)
258 n, err := m.MarshalTo(dAtA)
259 if err != nil {
260 return nil, err
261 }
262 return dAtA[:n], nil
263}
264
265func (m *RuleWithOperations) MarshalTo(dAtA []byte) (int, error) {
266 var i int
267 _ = i
268 var l int
269 _ = l
270 if len(m.Operations) > 0 {
271 for _, s := range m.Operations {
272 dAtA[i] = 0xa
273 i++
274 l = len(s)
275 for l >= 1<<7 {
276 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
277 l >>= 7
278 i++
279 }
280 dAtA[i] = uint8(l)
281 i++
282 i += copy(dAtA[i:], s)
283 }
284 }
285 dAtA[i] = 0x12
286 i++
287 i = encodeVarintGenerated(dAtA, i, uint64(m.Rule.Size()))
288 n3, err := m.Rule.MarshalTo(dAtA[i:])
289 if err != nil {
290 return 0, err
291 }
292 i += n3
293 return i, nil
294}
295
296func (m *ServiceReference) Marshal() (dAtA []byte, err error) {
297 size := m.Size()
298 dAtA = make([]byte, size)
299 n, err := m.MarshalTo(dAtA)
300 if err != nil {
301 return nil, err
302 }
303 return dAtA[:n], nil
304}
305
306func (m *ServiceReference) MarshalTo(dAtA []byte) (int, error) {
307 var i int
308 _ = i
309 var l int
310 _ = l
311 dAtA[i] = 0xa
312 i++
313 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
314 i += copy(dAtA[i:], m.Namespace)
315 dAtA[i] = 0x12
316 i++
317 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
318 i += copy(dAtA[i:], m.Name)
319 if m.Path != nil {
320 dAtA[i] = 0x1a
321 i++
322 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Path)))
323 i += copy(dAtA[i:], *m.Path)
324 }
325 return i, nil
326}
327
328func (m *ValidatingWebhookConfiguration) Marshal() (dAtA []byte, err error) {
329 size := m.Size()
330 dAtA = make([]byte, size)
331 n, err := m.MarshalTo(dAtA)
332 if err != nil {
333 return nil, err
334 }
335 return dAtA[:n], nil
336}
337
338func (m *ValidatingWebhookConfiguration) MarshalTo(dAtA []byte) (int, error) {
339 var i int
340 _ = i
341 var l int
342 _ = l
343 dAtA[i] = 0xa
344 i++
345 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
346 n4, err := m.ObjectMeta.MarshalTo(dAtA[i:])
347 if err != nil {
348 return 0, err
349 }
350 i += n4
351 if len(m.Webhooks) > 0 {
352 for _, msg := range m.Webhooks {
353 dAtA[i] = 0x12
354 i++
355 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
356 n, err := msg.MarshalTo(dAtA[i:])
357 if err != nil {
358 return 0, err
359 }
360 i += n
361 }
362 }
363 return i, nil
364}
365
366func (m *ValidatingWebhookConfigurationList) Marshal() (dAtA []byte, err error) {
367 size := m.Size()
368 dAtA = make([]byte, size)
369 n, err := m.MarshalTo(dAtA)
370 if err != nil {
371 return nil, err
372 }
373 return dAtA[:n], nil
374}
375
376func (m *ValidatingWebhookConfigurationList) MarshalTo(dAtA []byte) (int, error) {
377 var i int
378 _ = i
379 var l int
380 _ = l
381 dAtA[i] = 0xa
382 i++
383 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
384 n5, err := m.ListMeta.MarshalTo(dAtA[i:])
385 if err != nil {
386 return 0, err
387 }
388 i += n5
389 if len(m.Items) > 0 {
390 for _, msg := range m.Items {
391 dAtA[i] = 0x12
392 i++
393 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
394 n, err := msg.MarshalTo(dAtA[i:])
395 if err != nil {
396 return 0, err
397 }
398 i += n
399 }
400 }
401 return i, nil
402}
403
404func (m *Webhook) Marshal() (dAtA []byte, err error) {
405 size := m.Size()
406 dAtA = make([]byte, size)
407 n, err := m.MarshalTo(dAtA)
408 if err != nil {
409 return nil, err
410 }
411 return dAtA[:n], nil
412}
413
414func (m *Webhook) MarshalTo(dAtA []byte) (int, error) {
415 var i int
416 _ = i
417 var l int
418 _ = l
419 dAtA[i] = 0xa
420 i++
421 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
422 i += copy(dAtA[i:], m.Name)
423 dAtA[i] = 0x12
424 i++
425 i = encodeVarintGenerated(dAtA, i, uint64(m.ClientConfig.Size()))
426 n6, err := m.ClientConfig.MarshalTo(dAtA[i:])
427 if err != nil {
428 return 0, err
429 }
430 i += n6
431 if len(m.Rules) > 0 {
432 for _, msg := range m.Rules {
433 dAtA[i] = 0x1a
434 i++
435 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
436 n, err := msg.MarshalTo(dAtA[i:])
437 if err != nil {
438 return 0, err
439 }
440 i += n
441 }
442 }
443 if m.FailurePolicy != nil {
444 dAtA[i] = 0x22
445 i++
446 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FailurePolicy)))
447 i += copy(dAtA[i:], *m.FailurePolicy)
448 }
449 if m.NamespaceSelector != nil {
450 dAtA[i] = 0x2a
451 i++
452 i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size()))
453 n7, err := m.NamespaceSelector.MarshalTo(dAtA[i:])
454 if err != nil {
455 return 0, err
456 }
457 i += n7
458 }
459 if m.SideEffects != nil {
460 dAtA[i] = 0x32
461 i++
462 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.SideEffects)))
463 i += copy(dAtA[i:], *m.SideEffects)
464 }
465 return i, nil
466}
467
468func (m *WebhookClientConfig) Marshal() (dAtA []byte, err error) {
469 size := m.Size()
470 dAtA = make([]byte, size)
471 n, err := m.MarshalTo(dAtA)
472 if err != nil {
473 return nil, err
474 }
475 return dAtA[:n], nil
476}
477
478func (m *WebhookClientConfig) MarshalTo(dAtA []byte) (int, error) {
479 var i int
480 _ = i
481 var l int
482 _ = l
483 if m.Service != nil {
484 dAtA[i] = 0xa
485 i++
486 i = encodeVarintGenerated(dAtA, i, uint64(m.Service.Size()))
487 n8, err := m.Service.MarshalTo(dAtA[i:])
488 if err != nil {
489 return 0, err
490 }
491 i += n8
492 }
493 if m.CABundle != nil {
494 dAtA[i] = 0x12
495 i++
496 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CABundle)))
497 i += copy(dAtA[i:], m.CABundle)
498 }
499 if m.URL != nil {
500 dAtA[i] = 0x1a
501 i++
502 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.URL)))
503 i += copy(dAtA[i:], *m.URL)
504 }
505 return i, nil
506}
507
508func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
509 for v >= 1<<7 {
510 dAtA[offset] = uint8(v&0x7f | 0x80)
511 v >>= 7
512 offset++
513 }
514 dAtA[offset] = uint8(v)
515 return offset + 1
516}
517func (m *MutatingWebhookConfiguration) Size() (n int) {
518 var l int
519 _ = l
520 l = m.ObjectMeta.Size()
521 n += 1 + l + sovGenerated(uint64(l))
522 if len(m.Webhooks) > 0 {
523 for _, e := range m.Webhooks {
524 l = e.Size()
525 n += 1 + l + sovGenerated(uint64(l))
526 }
527 }
528 return n
529}
530
531func (m *MutatingWebhookConfigurationList) Size() (n int) {
532 var l int
533 _ = l
534 l = m.ListMeta.Size()
535 n += 1 + l + sovGenerated(uint64(l))
536 if len(m.Items) > 0 {
537 for _, e := range m.Items {
538 l = e.Size()
539 n += 1 + l + sovGenerated(uint64(l))
540 }
541 }
542 return n
543}
544
545func (m *Rule) Size() (n int) {
546 var l int
547 _ = l
548 if len(m.APIGroups) > 0 {
549 for _, s := range m.APIGroups {
550 l = len(s)
551 n += 1 + l + sovGenerated(uint64(l))
552 }
553 }
554 if len(m.APIVersions) > 0 {
555 for _, s := range m.APIVersions {
556 l = len(s)
557 n += 1 + l + sovGenerated(uint64(l))
558 }
559 }
560 if len(m.Resources) > 0 {
561 for _, s := range m.Resources {
562 l = len(s)
563 n += 1 + l + sovGenerated(uint64(l))
564 }
565 }
566 return n
567}
568
569func (m *RuleWithOperations) Size() (n int) {
570 var l int
571 _ = l
572 if len(m.Operations) > 0 {
573 for _, s := range m.Operations {
574 l = len(s)
575 n += 1 + l + sovGenerated(uint64(l))
576 }
577 }
578 l = m.Rule.Size()
579 n += 1 + l + sovGenerated(uint64(l))
580 return n
581}
582
583func (m *ServiceReference) Size() (n int) {
584 var l int
585 _ = l
586 l = len(m.Namespace)
587 n += 1 + l + sovGenerated(uint64(l))
588 l = len(m.Name)
589 n += 1 + l + sovGenerated(uint64(l))
590 if m.Path != nil {
591 l = len(*m.Path)
592 n += 1 + l + sovGenerated(uint64(l))
593 }
594 return n
595}
596
597func (m *ValidatingWebhookConfiguration) Size() (n int) {
598 var l int
599 _ = l
600 l = m.ObjectMeta.Size()
601 n += 1 + l + sovGenerated(uint64(l))
602 if len(m.Webhooks) > 0 {
603 for _, e := range m.Webhooks {
604 l = e.Size()
605 n += 1 + l + sovGenerated(uint64(l))
606 }
607 }
608 return n
609}
610
611func (m *ValidatingWebhookConfigurationList) Size() (n int) {
612 var l int
613 _ = l
614 l = m.ListMeta.Size()
615 n += 1 + l + sovGenerated(uint64(l))
616 if len(m.Items) > 0 {
617 for _, e := range m.Items {
618 l = e.Size()
619 n += 1 + l + sovGenerated(uint64(l))
620 }
621 }
622 return n
623}
624
625func (m *Webhook) Size() (n int) {
626 var l int
627 _ = l
628 l = len(m.Name)
629 n += 1 + l + sovGenerated(uint64(l))
630 l = m.ClientConfig.Size()
631 n += 1 + l + sovGenerated(uint64(l))
632 if len(m.Rules) > 0 {
633 for _, e := range m.Rules {
634 l = e.Size()
635 n += 1 + l + sovGenerated(uint64(l))
636 }
637 }
638 if m.FailurePolicy != nil {
639 l = len(*m.FailurePolicy)
640 n += 1 + l + sovGenerated(uint64(l))
641 }
642 if m.NamespaceSelector != nil {
643 l = m.NamespaceSelector.Size()
644 n += 1 + l + sovGenerated(uint64(l))
645 }
646 if m.SideEffects != nil {
647 l = len(*m.SideEffects)
648 n += 1 + l + sovGenerated(uint64(l))
649 }
650 return n
651}
652
653func (m *WebhookClientConfig) Size() (n int) {
654 var l int
655 _ = l
656 if m.Service != nil {
657 l = m.Service.Size()
658 n += 1 + l + sovGenerated(uint64(l))
659 }
660 if m.CABundle != nil {
661 l = len(m.CABundle)
662 n += 1 + l + sovGenerated(uint64(l))
663 }
664 if m.URL != nil {
665 l = len(*m.URL)
666 n += 1 + l + sovGenerated(uint64(l))
667 }
668 return n
669}
670
671func sovGenerated(x uint64) (n int) {
672 for {
673 n++
674 x >>= 7
675 if x == 0 {
676 break
677 }
678 }
679 return n
680}
681func sozGenerated(x uint64) (n int) {
682 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
683}
684func (this *MutatingWebhookConfiguration) String() string {
685 if this == nil {
686 return "nil"
687 }
688 s := strings.Join([]string{`&MutatingWebhookConfiguration{`,
689 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
690 `Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "Webhook", "Webhook", 1), `&`, ``, 1) + `,`,
691 `}`,
692 }, "")
693 return s
694}
695func (this *MutatingWebhookConfigurationList) String() string {
696 if this == nil {
697 return "nil"
698 }
699 s := strings.Join([]string{`&MutatingWebhookConfigurationList{`,
700 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
701 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "MutatingWebhookConfiguration", "MutatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
702 `}`,
703 }, "")
704 return s
705}
706func (this *Rule) String() string {
707 if this == nil {
708 return "nil"
709 }
710 s := strings.Join([]string{`&Rule{`,
711 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
712 `APIVersions:` + fmt.Sprintf("%v", this.APIVersions) + `,`,
713 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
714 `}`,
715 }, "")
716 return s
717}
718func (this *RuleWithOperations) String() string {
719 if this == nil {
720 return "nil"
721 }
722 s := strings.Join([]string{`&RuleWithOperations{`,
723 `Operations:` + fmt.Sprintf("%v", this.Operations) + `,`,
724 `Rule:` + strings.Replace(strings.Replace(this.Rule.String(), "Rule", "Rule", 1), `&`, ``, 1) + `,`,
725 `}`,
726 }, "")
727 return s
728}
729func (this *ServiceReference) String() string {
730 if this == nil {
731 return "nil"
732 }
733 s := strings.Join([]string{`&ServiceReference{`,
734 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
735 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
736 `Path:` + valueToStringGenerated(this.Path) + `,`,
737 `}`,
738 }, "")
739 return s
740}
741func (this *ValidatingWebhookConfiguration) String() string {
742 if this == nil {
743 return "nil"
744 }
745 s := strings.Join([]string{`&ValidatingWebhookConfiguration{`,
746 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
747 `Webhooks:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Webhooks), "Webhook", "Webhook", 1), `&`, ``, 1) + `,`,
748 `}`,
749 }, "")
750 return s
751}
752func (this *ValidatingWebhookConfigurationList) String() string {
753 if this == nil {
754 return "nil"
755 }
756 s := strings.Join([]string{`&ValidatingWebhookConfigurationList{`,
757 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
758 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ValidatingWebhookConfiguration", "ValidatingWebhookConfiguration", 1), `&`, ``, 1) + `,`,
759 `}`,
760 }, "")
761 return s
762}
763func (this *Webhook) String() string {
764 if this == nil {
765 return "nil"
766 }
767 s := strings.Join([]string{`&Webhook{`,
768 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
769 `ClientConfig:` + strings.Replace(strings.Replace(this.ClientConfig.String(), "WebhookClientConfig", "WebhookClientConfig", 1), `&`, ``, 1) + `,`,
770 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "RuleWithOperations", "RuleWithOperations", 1), `&`, ``, 1) + `,`,
771 `FailurePolicy:` + valueToStringGenerated(this.FailurePolicy) + `,`,
772 `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
773 `SideEffects:` + valueToStringGenerated(this.SideEffects) + `,`,
774 `}`,
775 }, "")
776 return s
777}
778func (this *WebhookClientConfig) String() string {
779 if this == nil {
780 return "nil"
781 }
782 s := strings.Join([]string{`&WebhookClientConfig{`,
783 `Service:` + strings.Replace(fmt.Sprintf("%v", this.Service), "ServiceReference", "ServiceReference", 1) + `,`,
784 `CABundle:` + valueToStringGenerated(this.CABundle) + `,`,
785 `URL:` + valueToStringGenerated(this.URL) + `,`,
786 `}`,
787 }, "")
788 return s
789}
790func valueToStringGenerated(v interface{}) string {
791 rv := reflect.ValueOf(v)
792 if rv.IsNil() {
793 return "nil"
794 }
795 pv := reflect.Indirect(rv).Interface()
796 return fmt.Sprintf("*%v", pv)
797}
798func (m *MutatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
799 l := len(dAtA)
800 iNdEx := 0
801 for iNdEx < l {
802 preIndex := iNdEx
803 var wire uint64
804 for shift := uint(0); ; shift += 7 {
805 if shift >= 64 {
806 return ErrIntOverflowGenerated
807 }
808 if iNdEx >= l {
809 return io.ErrUnexpectedEOF
810 }
811 b := dAtA[iNdEx]
812 iNdEx++
813 wire |= (uint64(b) & 0x7F) << shift
814 if b < 0x80 {
815 break
816 }
817 }
818 fieldNum := int32(wire >> 3)
819 wireType := int(wire & 0x7)
820 if wireType == 4 {
821 return fmt.Errorf("proto: MutatingWebhookConfiguration: wiretype end group for non-group")
822 }
823 if fieldNum <= 0 {
824 return fmt.Errorf("proto: MutatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
825 }
826 switch fieldNum {
827 case 1:
828 if wireType != 2 {
829 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
830 }
831 var msglen int
832 for shift := uint(0); ; shift += 7 {
833 if shift >= 64 {
834 return ErrIntOverflowGenerated
835 }
836 if iNdEx >= l {
837 return io.ErrUnexpectedEOF
838 }
839 b := dAtA[iNdEx]
840 iNdEx++
841 msglen |= (int(b) & 0x7F) << shift
842 if b < 0x80 {
843 break
844 }
845 }
846 if msglen < 0 {
847 return ErrInvalidLengthGenerated
848 }
849 postIndex := iNdEx + msglen
850 if postIndex > l {
851 return io.ErrUnexpectedEOF
852 }
853 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
854 return err
855 }
856 iNdEx = postIndex
857 case 2:
858 if wireType != 2 {
859 return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
860 }
861 var msglen int
862 for shift := uint(0); ; shift += 7 {
863 if shift >= 64 {
864 return ErrIntOverflowGenerated
865 }
866 if iNdEx >= l {
867 return io.ErrUnexpectedEOF
868 }
869 b := dAtA[iNdEx]
870 iNdEx++
871 msglen |= (int(b) & 0x7F) << shift
872 if b < 0x80 {
873 break
874 }
875 }
876 if msglen < 0 {
877 return ErrInvalidLengthGenerated
878 }
879 postIndex := iNdEx + msglen
880 if postIndex > l {
881 return io.ErrUnexpectedEOF
882 }
883 m.Webhooks = append(m.Webhooks, Webhook{})
884 if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
885 return err
886 }
887 iNdEx = postIndex
888 default:
889 iNdEx = preIndex
890 skippy, err := skipGenerated(dAtA[iNdEx:])
891 if err != nil {
892 return err
893 }
894 if skippy < 0 {
895 return ErrInvalidLengthGenerated
896 }
897 if (iNdEx + skippy) > l {
898 return io.ErrUnexpectedEOF
899 }
900 iNdEx += skippy
901 }
902 }
903
904 if iNdEx > l {
905 return io.ErrUnexpectedEOF
906 }
907 return nil
908}
909func (m *MutatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
910 l := len(dAtA)
911 iNdEx := 0
912 for iNdEx < l {
913 preIndex := iNdEx
914 var wire uint64
915 for shift := uint(0); ; shift += 7 {
916 if shift >= 64 {
917 return ErrIntOverflowGenerated
918 }
919 if iNdEx >= l {
920 return io.ErrUnexpectedEOF
921 }
922 b := dAtA[iNdEx]
923 iNdEx++
924 wire |= (uint64(b) & 0x7F) << shift
925 if b < 0x80 {
926 break
927 }
928 }
929 fieldNum := int32(wire >> 3)
930 wireType := int(wire & 0x7)
931 if wireType == 4 {
932 return fmt.Errorf("proto: MutatingWebhookConfigurationList: wiretype end group for non-group")
933 }
934 if fieldNum <= 0 {
935 return fmt.Errorf("proto: MutatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
936 }
937 switch fieldNum {
938 case 1:
939 if wireType != 2 {
940 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
941 }
942 var msglen int
943 for shift := uint(0); ; shift += 7 {
944 if shift >= 64 {
945 return ErrIntOverflowGenerated
946 }
947 if iNdEx >= l {
948 return io.ErrUnexpectedEOF
949 }
950 b := dAtA[iNdEx]
951 iNdEx++
952 msglen |= (int(b) & 0x7F) << shift
953 if b < 0x80 {
954 break
955 }
956 }
957 if msglen < 0 {
958 return ErrInvalidLengthGenerated
959 }
960 postIndex := iNdEx + msglen
961 if postIndex > l {
962 return io.ErrUnexpectedEOF
963 }
964 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
965 return err
966 }
967 iNdEx = postIndex
968 case 2:
969 if wireType != 2 {
970 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
971 }
972 var msglen int
973 for shift := uint(0); ; shift += 7 {
974 if shift >= 64 {
975 return ErrIntOverflowGenerated
976 }
977 if iNdEx >= l {
978 return io.ErrUnexpectedEOF
979 }
980 b := dAtA[iNdEx]
981 iNdEx++
982 msglen |= (int(b) & 0x7F) << shift
983 if b < 0x80 {
984 break
985 }
986 }
987 if msglen < 0 {
988 return ErrInvalidLengthGenerated
989 }
990 postIndex := iNdEx + msglen
991 if postIndex > l {
992 return io.ErrUnexpectedEOF
993 }
994 m.Items = append(m.Items, MutatingWebhookConfiguration{})
995 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
996 return err
997 }
998 iNdEx = postIndex
999 default:
1000 iNdEx = preIndex
1001 skippy, err := skipGenerated(dAtA[iNdEx:])
1002 if err != nil {
1003 return err
1004 }
1005 if skippy < 0 {
1006 return ErrInvalidLengthGenerated
1007 }
1008 if (iNdEx + skippy) > l {
1009 return io.ErrUnexpectedEOF
1010 }
1011 iNdEx += skippy
1012 }
1013 }
1014
1015 if iNdEx > l {
1016 return io.ErrUnexpectedEOF
1017 }
1018 return nil
1019}
1020func (m *Rule) Unmarshal(dAtA []byte) error {
1021 l := len(dAtA)
1022 iNdEx := 0
1023 for iNdEx < l {
1024 preIndex := iNdEx
1025 var wire uint64
1026 for shift := uint(0); ; shift += 7 {
1027 if shift >= 64 {
1028 return ErrIntOverflowGenerated
1029 }
1030 if iNdEx >= l {
1031 return io.ErrUnexpectedEOF
1032 }
1033 b := dAtA[iNdEx]
1034 iNdEx++
1035 wire |= (uint64(b) & 0x7F) << shift
1036 if b < 0x80 {
1037 break
1038 }
1039 }
1040 fieldNum := int32(wire >> 3)
1041 wireType := int(wire & 0x7)
1042 if wireType == 4 {
1043 return fmt.Errorf("proto: Rule: wiretype end group for non-group")
1044 }
1045 if fieldNum <= 0 {
1046 return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
1047 }
1048 switch fieldNum {
1049 case 1:
1050 if wireType != 2 {
1051 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
1052 }
1053 var stringLen uint64
1054 for shift := uint(0); ; shift += 7 {
1055 if shift >= 64 {
1056 return ErrIntOverflowGenerated
1057 }
1058 if iNdEx >= l {
1059 return io.ErrUnexpectedEOF
1060 }
1061 b := dAtA[iNdEx]
1062 iNdEx++
1063 stringLen |= (uint64(b) & 0x7F) << shift
1064 if b < 0x80 {
1065 break
1066 }
1067 }
1068 intStringLen := int(stringLen)
1069 if intStringLen < 0 {
1070 return ErrInvalidLengthGenerated
1071 }
1072 postIndex := iNdEx + intStringLen
1073 if postIndex > l {
1074 return io.ErrUnexpectedEOF
1075 }
1076 m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
1077 iNdEx = postIndex
1078 case 2:
1079 if wireType != 2 {
1080 return fmt.Errorf("proto: wrong wireType = %d for field APIVersions", wireType)
1081 }
1082 var stringLen uint64
1083 for shift := uint(0); ; shift += 7 {
1084 if shift >= 64 {
1085 return ErrIntOverflowGenerated
1086 }
1087 if iNdEx >= l {
1088 return io.ErrUnexpectedEOF
1089 }
1090 b := dAtA[iNdEx]
1091 iNdEx++
1092 stringLen |= (uint64(b) & 0x7F) << shift
1093 if b < 0x80 {
1094 break
1095 }
1096 }
1097 intStringLen := int(stringLen)
1098 if intStringLen < 0 {
1099 return ErrInvalidLengthGenerated
1100 }
1101 postIndex := iNdEx + intStringLen
1102 if postIndex > l {
1103 return io.ErrUnexpectedEOF
1104 }
1105 m.APIVersions = append(m.APIVersions, string(dAtA[iNdEx:postIndex]))
1106 iNdEx = postIndex
1107 case 3:
1108 if wireType != 2 {
1109 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
1110 }
1111 var stringLen uint64
1112 for shift := uint(0); ; shift += 7 {
1113 if shift >= 64 {
1114 return ErrIntOverflowGenerated
1115 }
1116 if iNdEx >= l {
1117 return io.ErrUnexpectedEOF
1118 }
1119 b := dAtA[iNdEx]
1120 iNdEx++
1121 stringLen |= (uint64(b) & 0x7F) << shift
1122 if b < 0x80 {
1123 break
1124 }
1125 }
1126 intStringLen := int(stringLen)
1127 if intStringLen < 0 {
1128 return ErrInvalidLengthGenerated
1129 }
1130 postIndex := iNdEx + intStringLen
1131 if postIndex > l {
1132 return io.ErrUnexpectedEOF
1133 }
1134 m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
1135 iNdEx = postIndex
1136 default:
1137 iNdEx = preIndex
1138 skippy, err := skipGenerated(dAtA[iNdEx:])
1139 if err != nil {
1140 return err
1141 }
1142 if skippy < 0 {
1143 return ErrInvalidLengthGenerated
1144 }
1145 if (iNdEx + skippy) > l {
1146 return io.ErrUnexpectedEOF
1147 }
1148 iNdEx += skippy
1149 }
1150 }
1151
1152 if iNdEx > l {
1153 return io.ErrUnexpectedEOF
1154 }
1155 return nil
1156}
1157func (m *RuleWithOperations) Unmarshal(dAtA []byte) error {
1158 l := len(dAtA)
1159 iNdEx := 0
1160 for iNdEx < l {
1161 preIndex := iNdEx
1162 var wire uint64
1163 for shift := uint(0); ; shift += 7 {
1164 if shift >= 64 {
1165 return ErrIntOverflowGenerated
1166 }
1167 if iNdEx >= l {
1168 return io.ErrUnexpectedEOF
1169 }
1170 b := dAtA[iNdEx]
1171 iNdEx++
1172 wire |= (uint64(b) & 0x7F) << shift
1173 if b < 0x80 {
1174 break
1175 }
1176 }
1177 fieldNum := int32(wire >> 3)
1178 wireType := int(wire & 0x7)
1179 if wireType == 4 {
1180 return fmt.Errorf("proto: RuleWithOperations: wiretype end group for non-group")
1181 }
1182 if fieldNum <= 0 {
1183 return fmt.Errorf("proto: RuleWithOperations: illegal tag %d (wire type %d)", fieldNum, wire)
1184 }
1185 switch fieldNum {
1186 case 1:
1187 if wireType != 2 {
1188 return fmt.Errorf("proto: wrong wireType = %d for field Operations", wireType)
1189 }
1190 var stringLen uint64
1191 for shift := uint(0); ; shift += 7 {
1192 if shift >= 64 {
1193 return ErrIntOverflowGenerated
1194 }
1195 if iNdEx >= l {
1196 return io.ErrUnexpectedEOF
1197 }
1198 b := dAtA[iNdEx]
1199 iNdEx++
1200 stringLen |= (uint64(b) & 0x7F) << shift
1201 if b < 0x80 {
1202 break
1203 }
1204 }
1205 intStringLen := int(stringLen)
1206 if intStringLen < 0 {
1207 return ErrInvalidLengthGenerated
1208 }
1209 postIndex := iNdEx + intStringLen
1210 if postIndex > l {
1211 return io.ErrUnexpectedEOF
1212 }
1213 m.Operations = append(m.Operations, OperationType(dAtA[iNdEx:postIndex]))
1214 iNdEx = postIndex
1215 case 2:
1216 if wireType != 2 {
1217 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType)
1218 }
1219 var msglen int
1220 for shift := uint(0); ; shift += 7 {
1221 if shift >= 64 {
1222 return ErrIntOverflowGenerated
1223 }
1224 if iNdEx >= l {
1225 return io.ErrUnexpectedEOF
1226 }
1227 b := dAtA[iNdEx]
1228 iNdEx++
1229 msglen |= (int(b) & 0x7F) << shift
1230 if b < 0x80 {
1231 break
1232 }
1233 }
1234 if msglen < 0 {
1235 return ErrInvalidLengthGenerated
1236 }
1237 postIndex := iNdEx + msglen
1238 if postIndex > l {
1239 return io.ErrUnexpectedEOF
1240 }
1241 if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1242 return err
1243 }
1244 iNdEx = postIndex
1245 default:
1246 iNdEx = preIndex
1247 skippy, err := skipGenerated(dAtA[iNdEx:])
1248 if err != nil {
1249 return err
1250 }
1251 if skippy < 0 {
1252 return ErrInvalidLengthGenerated
1253 }
1254 if (iNdEx + skippy) > l {
1255 return io.ErrUnexpectedEOF
1256 }
1257 iNdEx += skippy
1258 }
1259 }
1260
1261 if iNdEx > l {
1262 return io.ErrUnexpectedEOF
1263 }
1264 return nil
1265}
1266func (m *ServiceReference) Unmarshal(dAtA []byte) error {
1267 l := len(dAtA)
1268 iNdEx := 0
1269 for iNdEx < l {
1270 preIndex := iNdEx
1271 var wire uint64
1272 for shift := uint(0); ; shift += 7 {
1273 if shift >= 64 {
1274 return ErrIntOverflowGenerated
1275 }
1276 if iNdEx >= l {
1277 return io.ErrUnexpectedEOF
1278 }
1279 b := dAtA[iNdEx]
1280 iNdEx++
1281 wire |= (uint64(b) & 0x7F) << shift
1282 if b < 0x80 {
1283 break
1284 }
1285 }
1286 fieldNum := int32(wire >> 3)
1287 wireType := int(wire & 0x7)
1288 if wireType == 4 {
1289 return fmt.Errorf("proto: ServiceReference: wiretype end group for non-group")
1290 }
1291 if fieldNum <= 0 {
1292 return fmt.Errorf("proto: ServiceReference: illegal tag %d (wire type %d)", fieldNum, wire)
1293 }
1294 switch fieldNum {
1295 case 1:
1296 if wireType != 2 {
1297 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
1298 }
1299 var stringLen uint64
1300 for shift := uint(0); ; shift += 7 {
1301 if shift >= 64 {
1302 return ErrIntOverflowGenerated
1303 }
1304 if iNdEx >= l {
1305 return io.ErrUnexpectedEOF
1306 }
1307 b := dAtA[iNdEx]
1308 iNdEx++
1309 stringLen |= (uint64(b) & 0x7F) << shift
1310 if b < 0x80 {
1311 break
1312 }
1313 }
1314 intStringLen := int(stringLen)
1315 if intStringLen < 0 {
1316 return ErrInvalidLengthGenerated
1317 }
1318 postIndex := iNdEx + intStringLen
1319 if postIndex > l {
1320 return io.ErrUnexpectedEOF
1321 }
1322 m.Namespace = string(dAtA[iNdEx:postIndex])
1323 iNdEx = postIndex
1324 case 2:
1325 if wireType != 2 {
1326 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1327 }
1328 var stringLen uint64
1329 for shift := uint(0); ; shift += 7 {
1330 if shift >= 64 {
1331 return ErrIntOverflowGenerated
1332 }
1333 if iNdEx >= l {
1334 return io.ErrUnexpectedEOF
1335 }
1336 b := dAtA[iNdEx]
1337 iNdEx++
1338 stringLen |= (uint64(b) & 0x7F) << shift
1339 if b < 0x80 {
1340 break
1341 }
1342 }
1343 intStringLen := int(stringLen)
1344 if intStringLen < 0 {
1345 return ErrInvalidLengthGenerated
1346 }
1347 postIndex := iNdEx + intStringLen
1348 if postIndex > l {
1349 return io.ErrUnexpectedEOF
1350 }
1351 m.Name = string(dAtA[iNdEx:postIndex])
1352 iNdEx = postIndex
1353 case 3:
1354 if wireType != 2 {
1355 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
1356 }
1357 var stringLen uint64
1358 for shift := uint(0); ; shift += 7 {
1359 if shift >= 64 {
1360 return ErrIntOverflowGenerated
1361 }
1362 if iNdEx >= l {
1363 return io.ErrUnexpectedEOF
1364 }
1365 b := dAtA[iNdEx]
1366 iNdEx++
1367 stringLen |= (uint64(b) & 0x7F) << shift
1368 if b < 0x80 {
1369 break
1370 }
1371 }
1372 intStringLen := int(stringLen)
1373 if intStringLen < 0 {
1374 return ErrInvalidLengthGenerated
1375 }
1376 postIndex := iNdEx + intStringLen
1377 if postIndex > l {
1378 return io.ErrUnexpectedEOF
1379 }
1380 s := string(dAtA[iNdEx:postIndex])
1381 m.Path = &s
1382 iNdEx = postIndex
1383 default:
1384 iNdEx = preIndex
1385 skippy, err := skipGenerated(dAtA[iNdEx:])
1386 if err != nil {
1387 return err
1388 }
1389 if skippy < 0 {
1390 return ErrInvalidLengthGenerated
1391 }
1392 if (iNdEx + skippy) > l {
1393 return io.ErrUnexpectedEOF
1394 }
1395 iNdEx += skippy
1396 }
1397 }
1398
1399 if iNdEx > l {
1400 return io.ErrUnexpectedEOF
1401 }
1402 return nil
1403}
1404func (m *ValidatingWebhookConfiguration) Unmarshal(dAtA []byte) error {
1405 l := len(dAtA)
1406 iNdEx := 0
1407 for iNdEx < l {
1408 preIndex := iNdEx
1409 var wire uint64
1410 for shift := uint(0); ; shift += 7 {
1411 if shift >= 64 {
1412 return ErrIntOverflowGenerated
1413 }
1414 if iNdEx >= l {
1415 return io.ErrUnexpectedEOF
1416 }
1417 b := dAtA[iNdEx]
1418 iNdEx++
1419 wire |= (uint64(b) & 0x7F) << shift
1420 if b < 0x80 {
1421 break
1422 }
1423 }
1424 fieldNum := int32(wire >> 3)
1425 wireType := int(wire & 0x7)
1426 if wireType == 4 {
1427 return fmt.Errorf("proto: ValidatingWebhookConfiguration: wiretype end group for non-group")
1428 }
1429 if fieldNum <= 0 {
1430 return fmt.Errorf("proto: ValidatingWebhookConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
1431 }
1432 switch fieldNum {
1433 case 1:
1434 if wireType != 2 {
1435 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1436 }
1437 var msglen int
1438 for shift := uint(0); ; shift += 7 {
1439 if shift >= 64 {
1440 return ErrIntOverflowGenerated
1441 }
1442 if iNdEx >= l {
1443 return io.ErrUnexpectedEOF
1444 }
1445 b := dAtA[iNdEx]
1446 iNdEx++
1447 msglen |= (int(b) & 0x7F) << shift
1448 if b < 0x80 {
1449 break
1450 }
1451 }
1452 if msglen < 0 {
1453 return ErrInvalidLengthGenerated
1454 }
1455 postIndex := iNdEx + msglen
1456 if postIndex > l {
1457 return io.ErrUnexpectedEOF
1458 }
1459 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1460 return err
1461 }
1462 iNdEx = postIndex
1463 case 2:
1464 if wireType != 2 {
1465 return fmt.Errorf("proto: wrong wireType = %d for field Webhooks", wireType)
1466 }
1467 var msglen int
1468 for shift := uint(0); ; shift += 7 {
1469 if shift >= 64 {
1470 return ErrIntOverflowGenerated
1471 }
1472 if iNdEx >= l {
1473 return io.ErrUnexpectedEOF
1474 }
1475 b := dAtA[iNdEx]
1476 iNdEx++
1477 msglen |= (int(b) & 0x7F) << shift
1478 if b < 0x80 {
1479 break
1480 }
1481 }
1482 if msglen < 0 {
1483 return ErrInvalidLengthGenerated
1484 }
1485 postIndex := iNdEx + msglen
1486 if postIndex > l {
1487 return io.ErrUnexpectedEOF
1488 }
1489 m.Webhooks = append(m.Webhooks, Webhook{})
1490 if err := m.Webhooks[len(m.Webhooks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1491 return err
1492 }
1493 iNdEx = postIndex
1494 default:
1495 iNdEx = preIndex
1496 skippy, err := skipGenerated(dAtA[iNdEx:])
1497 if err != nil {
1498 return err
1499 }
1500 if skippy < 0 {
1501 return ErrInvalidLengthGenerated
1502 }
1503 if (iNdEx + skippy) > l {
1504 return io.ErrUnexpectedEOF
1505 }
1506 iNdEx += skippy
1507 }
1508 }
1509
1510 if iNdEx > l {
1511 return io.ErrUnexpectedEOF
1512 }
1513 return nil
1514}
1515func (m *ValidatingWebhookConfigurationList) Unmarshal(dAtA []byte) error {
1516 l := len(dAtA)
1517 iNdEx := 0
1518 for iNdEx < l {
1519 preIndex := iNdEx
1520 var wire uint64
1521 for shift := uint(0); ; shift += 7 {
1522 if shift >= 64 {
1523 return ErrIntOverflowGenerated
1524 }
1525 if iNdEx >= l {
1526 return io.ErrUnexpectedEOF
1527 }
1528 b := dAtA[iNdEx]
1529 iNdEx++
1530 wire |= (uint64(b) & 0x7F) << shift
1531 if b < 0x80 {
1532 break
1533 }
1534 }
1535 fieldNum := int32(wire >> 3)
1536 wireType := int(wire & 0x7)
1537 if wireType == 4 {
1538 return fmt.Errorf("proto: ValidatingWebhookConfigurationList: wiretype end group for non-group")
1539 }
1540 if fieldNum <= 0 {
1541 return fmt.Errorf("proto: ValidatingWebhookConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
1542 }
1543 switch fieldNum {
1544 case 1:
1545 if wireType != 2 {
1546 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1547 }
1548 var msglen int
1549 for shift := uint(0); ; shift += 7 {
1550 if shift >= 64 {
1551 return ErrIntOverflowGenerated
1552 }
1553 if iNdEx >= l {
1554 return io.ErrUnexpectedEOF
1555 }
1556 b := dAtA[iNdEx]
1557 iNdEx++
1558 msglen |= (int(b) & 0x7F) << shift
1559 if b < 0x80 {
1560 break
1561 }
1562 }
1563 if msglen < 0 {
1564 return ErrInvalidLengthGenerated
1565 }
1566 postIndex := iNdEx + msglen
1567 if postIndex > l {
1568 return io.ErrUnexpectedEOF
1569 }
1570 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1571 return err
1572 }
1573 iNdEx = postIndex
1574 case 2:
1575 if wireType != 2 {
1576 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1577 }
1578 var msglen int
1579 for shift := uint(0); ; shift += 7 {
1580 if shift >= 64 {
1581 return ErrIntOverflowGenerated
1582 }
1583 if iNdEx >= l {
1584 return io.ErrUnexpectedEOF
1585 }
1586 b := dAtA[iNdEx]
1587 iNdEx++
1588 msglen |= (int(b) & 0x7F) << shift
1589 if b < 0x80 {
1590 break
1591 }
1592 }
1593 if msglen < 0 {
1594 return ErrInvalidLengthGenerated
1595 }
1596 postIndex := iNdEx + msglen
1597 if postIndex > l {
1598 return io.ErrUnexpectedEOF
1599 }
1600 m.Items = append(m.Items, ValidatingWebhookConfiguration{})
1601 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1602 return err
1603 }
1604 iNdEx = postIndex
1605 default:
1606 iNdEx = preIndex
1607 skippy, err := skipGenerated(dAtA[iNdEx:])
1608 if err != nil {
1609 return err
1610 }
1611 if skippy < 0 {
1612 return ErrInvalidLengthGenerated
1613 }
1614 if (iNdEx + skippy) > l {
1615 return io.ErrUnexpectedEOF
1616 }
1617 iNdEx += skippy
1618 }
1619 }
1620
1621 if iNdEx > l {
1622 return io.ErrUnexpectedEOF
1623 }
1624 return nil
1625}
1626func (m *Webhook) Unmarshal(dAtA []byte) error {
1627 l := len(dAtA)
1628 iNdEx := 0
1629 for iNdEx < l {
1630 preIndex := iNdEx
1631 var wire uint64
1632 for shift := uint(0); ; shift += 7 {
1633 if shift >= 64 {
1634 return ErrIntOverflowGenerated
1635 }
1636 if iNdEx >= l {
1637 return io.ErrUnexpectedEOF
1638 }
1639 b := dAtA[iNdEx]
1640 iNdEx++
1641 wire |= (uint64(b) & 0x7F) << shift
1642 if b < 0x80 {
1643 break
1644 }
1645 }
1646 fieldNum := int32(wire >> 3)
1647 wireType := int(wire & 0x7)
1648 if wireType == 4 {
1649 return fmt.Errorf("proto: Webhook: wiretype end group for non-group")
1650 }
1651 if fieldNum <= 0 {
1652 return fmt.Errorf("proto: Webhook: illegal tag %d (wire type %d)", fieldNum, wire)
1653 }
1654 switch fieldNum {
1655 case 1:
1656 if wireType != 2 {
1657 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1658 }
1659 var stringLen uint64
1660 for shift := uint(0); ; shift += 7 {
1661 if shift >= 64 {
1662 return ErrIntOverflowGenerated
1663 }
1664 if iNdEx >= l {
1665 return io.ErrUnexpectedEOF
1666 }
1667 b := dAtA[iNdEx]
1668 iNdEx++
1669 stringLen |= (uint64(b) & 0x7F) << shift
1670 if b < 0x80 {
1671 break
1672 }
1673 }
1674 intStringLen := int(stringLen)
1675 if intStringLen < 0 {
1676 return ErrInvalidLengthGenerated
1677 }
1678 postIndex := iNdEx + intStringLen
1679 if postIndex > l {
1680 return io.ErrUnexpectedEOF
1681 }
1682 m.Name = string(dAtA[iNdEx:postIndex])
1683 iNdEx = postIndex
1684 case 2:
1685 if wireType != 2 {
1686 return fmt.Errorf("proto: wrong wireType = %d for field ClientConfig", wireType)
1687 }
1688 var msglen int
1689 for shift := uint(0); ; shift += 7 {
1690 if shift >= 64 {
1691 return ErrIntOverflowGenerated
1692 }
1693 if iNdEx >= l {
1694 return io.ErrUnexpectedEOF
1695 }
1696 b := dAtA[iNdEx]
1697 iNdEx++
1698 msglen |= (int(b) & 0x7F) << shift
1699 if b < 0x80 {
1700 break
1701 }
1702 }
1703 if msglen < 0 {
1704 return ErrInvalidLengthGenerated
1705 }
1706 postIndex := iNdEx + msglen
1707 if postIndex > l {
1708 return io.ErrUnexpectedEOF
1709 }
1710 if err := m.ClientConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1711 return err
1712 }
1713 iNdEx = postIndex
1714 case 3:
1715 if wireType != 2 {
1716 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
1717 }
1718 var msglen int
1719 for shift := uint(0); ; shift += 7 {
1720 if shift >= 64 {
1721 return ErrIntOverflowGenerated
1722 }
1723 if iNdEx >= l {
1724 return io.ErrUnexpectedEOF
1725 }
1726 b := dAtA[iNdEx]
1727 iNdEx++
1728 msglen |= (int(b) & 0x7F) << shift
1729 if b < 0x80 {
1730 break
1731 }
1732 }
1733 if msglen < 0 {
1734 return ErrInvalidLengthGenerated
1735 }
1736 postIndex := iNdEx + msglen
1737 if postIndex > l {
1738 return io.ErrUnexpectedEOF
1739 }
1740 m.Rules = append(m.Rules, RuleWithOperations{})
1741 if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1742 return err
1743 }
1744 iNdEx = postIndex
1745 case 4:
1746 if wireType != 2 {
1747 return fmt.Errorf("proto: wrong wireType = %d for field FailurePolicy", wireType)
1748 }
1749 var stringLen uint64
1750 for shift := uint(0); ; shift += 7 {
1751 if shift >= 64 {
1752 return ErrIntOverflowGenerated
1753 }
1754 if iNdEx >= l {
1755 return io.ErrUnexpectedEOF
1756 }
1757 b := dAtA[iNdEx]
1758 iNdEx++
1759 stringLen |= (uint64(b) & 0x7F) << shift
1760 if b < 0x80 {
1761 break
1762 }
1763 }
1764 intStringLen := int(stringLen)
1765 if intStringLen < 0 {
1766 return ErrInvalidLengthGenerated
1767 }
1768 postIndex := iNdEx + intStringLen
1769 if postIndex > l {
1770 return io.ErrUnexpectedEOF
1771 }
1772 s := FailurePolicyType(dAtA[iNdEx:postIndex])
1773 m.FailurePolicy = &s
1774 iNdEx = postIndex
1775 case 5:
1776 if wireType != 2 {
1777 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
1778 }
1779 var msglen int
1780 for shift := uint(0); ; shift += 7 {
1781 if shift >= 64 {
1782 return ErrIntOverflowGenerated
1783 }
1784 if iNdEx >= l {
1785 return io.ErrUnexpectedEOF
1786 }
1787 b := dAtA[iNdEx]
1788 iNdEx++
1789 msglen |= (int(b) & 0x7F) << shift
1790 if b < 0x80 {
1791 break
1792 }
1793 }
1794 if msglen < 0 {
1795 return ErrInvalidLengthGenerated
1796 }
1797 postIndex := iNdEx + msglen
1798 if postIndex > l {
1799 return io.ErrUnexpectedEOF
1800 }
1801 if m.NamespaceSelector == nil {
1802 m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
1803 }
1804 if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1805 return err
1806 }
1807 iNdEx = postIndex
1808 case 6:
1809 if wireType != 2 {
1810 return fmt.Errorf("proto: wrong wireType = %d for field SideEffects", wireType)
1811 }
1812 var stringLen uint64
1813 for shift := uint(0); ; shift += 7 {
1814 if shift >= 64 {
1815 return ErrIntOverflowGenerated
1816 }
1817 if iNdEx >= l {
1818 return io.ErrUnexpectedEOF
1819 }
1820 b := dAtA[iNdEx]
1821 iNdEx++
1822 stringLen |= (uint64(b) & 0x7F) << shift
1823 if b < 0x80 {
1824 break
1825 }
1826 }
1827 intStringLen := int(stringLen)
1828 if intStringLen < 0 {
1829 return ErrInvalidLengthGenerated
1830 }
1831 postIndex := iNdEx + intStringLen
1832 if postIndex > l {
1833 return io.ErrUnexpectedEOF
1834 }
1835 s := SideEffectClass(dAtA[iNdEx:postIndex])
1836 m.SideEffects = &s
1837 iNdEx = postIndex
1838 default:
1839 iNdEx = preIndex
1840 skippy, err := skipGenerated(dAtA[iNdEx:])
1841 if err != nil {
1842 return err
1843 }
1844 if skippy < 0 {
1845 return ErrInvalidLengthGenerated
1846 }
1847 if (iNdEx + skippy) > l {
1848 return io.ErrUnexpectedEOF
1849 }
1850 iNdEx += skippy
1851 }
1852 }
1853
1854 if iNdEx > l {
1855 return io.ErrUnexpectedEOF
1856 }
1857 return nil
1858}
1859func (m *WebhookClientConfig) Unmarshal(dAtA []byte) error {
1860 l := len(dAtA)
1861 iNdEx := 0
1862 for iNdEx < l {
1863 preIndex := iNdEx
1864 var wire uint64
1865 for shift := uint(0); ; shift += 7 {
1866 if shift >= 64 {
1867 return ErrIntOverflowGenerated
1868 }
1869 if iNdEx >= l {
1870 return io.ErrUnexpectedEOF
1871 }
1872 b := dAtA[iNdEx]
1873 iNdEx++
1874 wire |= (uint64(b) & 0x7F) << shift
1875 if b < 0x80 {
1876 break
1877 }
1878 }
1879 fieldNum := int32(wire >> 3)
1880 wireType := int(wire & 0x7)
1881 if wireType == 4 {
1882 return fmt.Errorf("proto: WebhookClientConfig: wiretype end group for non-group")
1883 }
1884 if fieldNum <= 0 {
1885 return fmt.Errorf("proto: WebhookClientConfig: illegal tag %d (wire type %d)", fieldNum, wire)
1886 }
1887 switch fieldNum {
1888 case 1:
1889 if wireType != 2 {
1890 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType)
1891 }
1892 var msglen int
1893 for shift := uint(0); ; shift += 7 {
1894 if shift >= 64 {
1895 return ErrIntOverflowGenerated
1896 }
1897 if iNdEx >= l {
1898 return io.ErrUnexpectedEOF
1899 }
1900 b := dAtA[iNdEx]
1901 iNdEx++
1902 msglen |= (int(b) & 0x7F) << shift
1903 if b < 0x80 {
1904 break
1905 }
1906 }
1907 if msglen < 0 {
1908 return ErrInvalidLengthGenerated
1909 }
1910 postIndex := iNdEx + msglen
1911 if postIndex > l {
1912 return io.ErrUnexpectedEOF
1913 }
1914 if m.Service == nil {
1915 m.Service = &ServiceReference{}
1916 }
1917 if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1918 return err
1919 }
1920 iNdEx = postIndex
1921 case 2:
1922 if wireType != 2 {
1923 return fmt.Errorf("proto: wrong wireType = %d for field CABundle", wireType)
1924 }
1925 var byteLen int
1926 for shift := uint(0); ; shift += 7 {
1927 if shift >= 64 {
1928 return ErrIntOverflowGenerated
1929 }
1930 if iNdEx >= l {
1931 return io.ErrUnexpectedEOF
1932 }
1933 b := dAtA[iNdEx]
1934 iNdEx++
1935 byteLen |= (int(b) & 0x7F) << shift
1936 if b < 0x80 {
1937 break
1938 }
1939 }
1940 if byteLen < 0 {
1941 return ErrInvalidLengthGenerated
1942 }
1943 postIndex := iNdEx + byteLen
1944 if postIndex > l {
1945 return io.ErrUnexpectedEOF
1946 }
1947 m.CABundle = append(m.CABundle[:0], dAtA[iNdEx:postIndex]...)
1948 if m.CABundle == nil {
1949 m.CABundle = []byte{}
1950 }
1951 iNdEx = postIndex
1952 case 3:
1953 if wireType != 2 {
1954 return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
1955 }
1956 var stringLen uint64
1957 for shift := uint(0); ; shift += 7 {
1958 if shift >= 64 {
1959 return ErrIntOverflowGenerated
1960 }
1961 if iNdEx >= l {
1962 return io.ErrUnexpectedEOF
1963 }
1964 b := dAtA[iNdEx]
1965 iNdEx++
1966 stringLen |= (uint64(b) & 0x7F) << shift
1967 if b < 0x80 {
1968 break
1969 }
1970 }
1971 intStringLen := int(stringLen)
1972 if intStringLen < 0 {
1973 return ErrInvalidLengthGenerated
1974 }
1975 postIndex := iNdEx + intStringLen
1976 if postIndex > l {
1977 return io.ErrUnexpectedEOF
1978 }
1979 s := string(dAtA[iNdEx:postIndex])
1980 m.URL = &s
1981 iNdEx = postIndex
1982 default:
1983 iNdEx = preIndex
1984 skippy, err := skipGenerated(dAtA[iNdEx:])
1985 if err != nil {
1986 return err
1987 }
1988 if skippy < 0 {
1989 return ErrInvalidLengthGenerated
1990 }
1991 if (iNdEx + skippy) > l {
1992 return io.ErrUnexpectedEOF
1993 }
1994 iNdEx += skippy
1995 }
1996 }
1997
1998 if iNdEx > l {
1999 return io.ErrUnexpectedEOF
2000 }
2001 return nil
2002}
2003func skipGenerated(dAtA []byte) (n int, err error) {
2004 l := len(dAtA)
2005 iNdEx := 0
2006 for iNdEx < l {
2007 var wire uint64
2008 for shift := uint(0); ; shift += 7 {
2009 if shift >= 64 {
2010 return 0, ErrIntOverflowGenerated
2011 }
2012 if iNdEx >= l {
2013 return 0, io.ErrUnexpectedEOF
2014 }
2015 b := dAtA[iNdEx]
2016 iNdEx++
2017 wire |= (uint64(b) & 0x7F) << shift
2018 if b < 0x80 {
2019 break
2020 }
2021 }
2022 wireType := int(wire & 0x7)
2023 switch wireType {
2024 case 0:
2025 for shift := uint(0); ; shift += 7 {
2026 if shift >= 64 {
2027 return 0, ErrIntOverflowGenerated
2028 }
2029 if iNdEx >= l {
2030 return 0, io.ErrUnexpectedEOF
2031 }
2032 iNdEx++
2033 if dAtA[iNdEx-1] < 0x80 {
2034 break
2035 }
2036 }
2037 return iNdEx, nil
2038 case 1:
2039 iNdEx += 8
2040 return iNdEx, nil
2041 case 2:
2042 var length int
2043 for shift := uint(0); ; shift += 7 {
2044 if shift >= 64 {
2045 return 0, ErrIntOverflowGenerated
2046 }
2047 if iNdEx >= l {
2048 return 0, io.ErrUnexpectedEOF
2049 }
2050 b := dAtA[iNdEx]
2051 iNdEx++
2052 length |= (int(b) & 0x7F) << shift
2053 if b < 0x80 {
2054 break
2055 }
2056 }
2057 iNdEx += length
2058 if length < 0 {
2059 return 0, ErrInvalidLengthGenerated
2060 }
2061 return iNdEx, nil
2062 case 3:
2063 for {
2064 var innerWire uint64
2065 var start int = iNdEx
2066 for shift := uint(0); ; shift += 7 {
2067 if shift >= 64 {
2068 return 0, ErrIntOverflowGenerated
2069 }
2070 if iNdEx >= l {
2071 return 0, io.ErrUnexpectedEOF
2072 }
2073 b := dAtA[iNdEx]
2074 iNdEx++
2075 innerWire |= (uint64(b) & 0x7F) << shift
2076 if b < 0x80 {
2077 break
2078 }
2079 }
2080 innerWireType := int(innerWire & 0x7)
2081 if innerWireType == 4 {
2082 break
2083 }
2084 next, err := skipGenerated(dAtA[start:])
2085 if err != nil {
2086 return 0, err
2087 }
2088 iNdEx = start + next
2089 }
2090 return iNdEx, nil
2091 case 4:
2092 return iNdEx, nil
2093 case 5:
2094 iNdEx += 4
2095 return iNdEx, nil
2096 default:
2097 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2098 }
2099 }
2100 panic("unreachable")
2101}
2102
2103var (
2104 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
2105 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
2106)
2107
2108func init() {
2109 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1beta1/generated.proto", fileDescriptorGenerated)
2110}
2111
2112var fileDescriptorGenerated = []byte{
2113 // 906 bytes of a gzipped FileDescriptorProto
2114 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x54, 0xcf, 0x6f, 0xe3, 0x44,
2115 0x14, 0x8e, 0x37, 0x29, 0x49, 0x26, 0x89, 0x76, 0x3b, 0x80, 0x14, 0xaa, 0x95, 0x1d, 0xe5, 0x80,
2116 0x22, 0xa1, 0xb5, 0x49, 0x41, 0x08, 0x21, 0x10, 0xaa, 0x0b, 0x0b, 0x95, 0xba, 0xbb, 0x61, 0x0a,
2117 0xbb, 0x12, 0xe2, 0xc0, 0xc4, 0x79, 0x49, 0x86, 0xf8, 0x97, 0x66, 0xc6, 0x59, 0x7a, 0x43, 0xe2,
2118 0x1f, 0x40, 0x42, 0xfc, 0x0d, 0xfc, 0x15, 0xdc, 0x7b, 0xdc, 0x0b, 0x62, 0x4f, 0x16, 0x35, 0x67,
2119 0x0e, 0x5c, 0x7b, 0x42, 0x63, 0x3b, 0x71, 0xd2, 0x6c, 0xbb, 0xe9, 0x85, 0x03, 0x37, 0xcf, 0xf7,
2120 0xe6, 0xfb, 0xde, 0xfb, 0x9e, 0xdf, 0x1b, 0xf4, 0xc5, 0xec, 0x7d, 0x61, 0xb2, 0xc0, 0x9a, 0x45,
2121 0x43, 0xe0, 0x3e, 0x48, 0x10, 0xd6, 0x1c, 0xfc, 0x51, 0xc0, 0xad, 0x3c, 0x40, 0x43, 0x66, 0xd1,
2122 0x91, 0xc7, 0x84, 0x60, 0x81, 0xcf, 0x61, 0xc2, 0x84, 0xe4, 0x54, 0xb2, 0xc0, 0xb7, 0xe6, 0xfd,
2123 0x21, 0x48, 0xda, 0xb7, 0x26, 0xe0, 0x03, 0xa7, 0x12, 0x46, 0x66, 0xc8, 0x03, 0x19, 0xe0, 0x5e,
2124 0xc6, 0x34, 0x69, 0xc8, 0xcc, 0x17, 0x32, 0xcd, 0x9c, 0xb9, 0x77, 0x6f, 0xc2, 0xe4, 0x34, 0x1a,
2125 0x9a, 0x4e, 0xe0, 0x59, 0x93, 0x60, 0x12, 0x58, 0xa9, 0xc0, 0x30, 0x1a, 0xa7, 0xa7, 0xf4, 0x90,
2126 0x7e, 0x65, 0xc2, 0x7b, 0xef, 0x16, 0x25, 0x79, 0xd4, 0x99, 0x32, 0x1f, 0xf8, 0xa9, 0x15, 0xce,
2127 0x26, 0x0a, 0x10, 0x96, 0x07, 0x92, 0x5a, 0xf3, 0x8d, 0x72, 0xf6, 0xac, 0xab, 0x58, 0x3c, 0xf2,
2128 0x25, 0xf3, 0x60, 0x83, 0xf0, 0xde, 0xcb, 0x08, 0xc2, 0x99, 0x82, 0x47, 0x2f, 0xf3, 0xba, 0xbf,
2129 0x6b, 0xe8, 0xee, 0x83, 0x48, 0x52, 0xc9, 0xfc, 0xc9, 0x13, 0x18, 0x4e, 0x83, 0x60, 0x76, 0x18,
2130 0xf8, 0x63, 0x36, 0x89, 0x32, 0xdb, 0xf8, 0x5b, 0x54, 0x53, 0x45, 0x8e, 0xa8, 0xa4, 0x6d, 0xad,
2131 0xa3, 0xf5, 0x1a, 0xfb, 0x6f, 0x9b, 0x45, 0xaf, 0x96, 0xb9, 0xcc, 0x70, 0x36, 0x51, 0x80, 0x30,
2132 0xd5, 0x6d, 0x73, 0xde, 0x37, 0x1f, 0x0d, 0xbf, 0x03, 0x47, 0x3e, 0x00, 0x49, 0x6d, 0x7c, 0x16,
2133 0x1b, 0xa5, 0x24, 0x36, 0x50, 0x81, 0x91, 0xa5, 0x2a, 0x3e, 0x41, 0xb5, 0x3c, 0xb3, 0x68, 0xdf,
2134 0xea, 0x94, 0x7b, 0x8d, 0xfd, 0xbe, 0xb9, 0xed, 0xdf, 0x30, 0x73, 0xa6, 0x5d, 0x51, 0x29, 0x48,
2135 0xed, 0x69, 0x2e, 0xd4, 0xfd, 0x5b, 0x43, 0x9d, 0xeb, 0x7c, 0x1d, 0x33, 0x21, 0xf1, 0x37, 0x1b,
2136 0xde, 0xcc, 0xed, 0xbc, 0x29, 0x76, 0xea, 0xec, 0x4e, 0xee, 0xac, 0xb6, 0x40, 0x56, 0x7c, 0xcd,
2137 0xd0, 0x0e, 0x93, 0xe0, 0x2d, 0x4c, 0xdd, 0xdf, 0xde, 0xd4, 0x75, 0x85, 0xdb, 0xad, 0x3c, 0xe5,
2138 0xce, 0x91, 0x12, 0x27, 0x59, 0x8e, 0xee, 0xcf, 0x1a, 0xaa, 0x90, 0xc8, 0x05, 0xfc, 0x16, 0xaa,
2139 0xd3, 0x90, 0x7d, 0xc6, 0x83, 0x28, 0x14, 0x6d, 0xad, 0x53, 0xee, 0xd5, 0xed, 0x56, 0x12, 0x1b,
2140 0xf5, 0x83, 0xc1, 0x51, 0x06, 0x92, 0x22, 0x8e, 0xfb, 0xa8, 0x41, 0x43, 0xf6, 0x18, 0xb8, 0x2a,
2141 0x25, 0x2b, 0xb4, 0x6e, 0xdf, 0x4e, 0x62, 0xa3, 0x71, 0x30, 0x38, 0x5a, 0xc0, 0x64, 0xf5, 0x8e,
2142 0xd2, 0xe7, 0x20, 0x82, 0x88, 0x3b, 0x20, 0xda, 0xe5, 0x42, 0x9f, 0x2c, 0x40, 0x52, 0xc4, 0xbb,
2143 0xbf, 0x6a, 0x08, 0xab, 0xaa, 0x9e, 0x30, 0x39, 0x7d, 0x14, 0x42, 0xe6, 0x40, 0xe0, 0x8f, 0x11,
2144 0x0a, 0x96, 0xa7, 0xbc, 0x48, 0x23, 0x9d, 0x8f, 0x25, 0x7a, 0x11, 0x1b, 0xad, 0xe5, 0xe9, 0xcb,
2145 0xd3, 0x10, 0xc8, 0x0a, 0x05, 0x0f, 0x50, 0x85, 0x47, 0x2e, 0xb4, 0x6f, 0x6d, 0xfc, 0xb4, 0x97,
2146 0x74, 0x56, 0x15, 0x63, 0x37, 0xf3, 0x0e, 0xa6, 0x0d, 0x23, 0xa9, 0x52, 0xf7, 0x47, 0x0d, 0xdd,
2147 0x39, 0x01, 0x3e, 0x67, 0x0e, 0x10, 0x18, 0x03, 0x07, 0xdf, 0x01, 0x6c, 0xa1, 0xba, 0x4f, 0x3d,
2148 0x10, 0x21, 0x75, 0x20, 0x1d, 0x90, 0xba, 0xbd, 0x9b, 0x73, 0xeb, 0x0f, 0x17, 0x01, 0x52, 0xdc,
2149 0xc1, 0x1d, 0x54, 0x51, 0x87, 0xb4, 0xae, 0x7a, 0x91, 0x47, 0xdd, 0x25, 0x69, 0x04, 0xdf, 0x45,
2150 0x95, 0x90, 0xca, 0x69, 0xbb, 0x9c, 0xde, 0xa8, 0xa9, 0xe8, 0x80, 0xca, 0x29, 0x49, 0xd1, 0xee,
2151 0x1f, 0x1a, 0xd2, 0x1f, 0x53, 0x97, 0x8d, 0xfe, 0x77, 0xfb, 0xf8, 0x8f, 0x86, 0xba, 0xd7, 0x3b,
2152 0xfb, 0x0f, 0x36, 0xd2, 0x5b, 0xdf, 0xc8, 0xcf, 0xb7, 0xb7, 0x75, 0x7d, 0xe9, 0x57, 0xec, 0xe4,
2153 0x2f, 0x15, 0x54, 0xcd, 0xaf, 0x2f, 0x27, 0x43, 0xbb, 0x72, 0x32, 0x9e, 0xa2, 0xa6, 0xe3, 0x32,
2154 0xf0, 0x65, 0x26, 0x9d, 0xcf, 0xf6, 0x47, 0x37, 0x6e, 0xfd, 0xe1, 0x8a, 0x88, 0xfd, 0x5a, 0x9e,
2155 0xa8, 0xb9, 0x8a, 0x92, 0xb5, 0x44, 0x98, 0xa2, 0x1d, 0xb5, 0x02, 0xd9, 0x36, 0x37, 0xf6, 0x3f,
2156 0xbc, 0xd9, 0x36, 0xad, 0xaf, 0x76, 0xd1, 0x09, 0x15, 0x13, 0x24, 0x53, 0xc6, 0xc7, 0xa8, 0x35,
2157 0xa6, 0xcc, 0x8d, 0x38, 0x0c, 0x02, 0x97, 0x39, 0xa7, 0xed, 0x4a, 0xda, 0x86, 0x37, 0x93, 0xd8,
2158 0x68, 0xdd, 0x5f, 0x0d, 0x5c, 0xc4, 0xc6, 0xee, 0x1a, 0x90, 0xae, 0xfe, 0x3a, 0x19, 0x7f, 0x8f,
2159 0x76, 0x97, 0x2b, 0x77, 0x02, 0x2e, 0x38, 0x32, 0xe0, 0xed, 0x9d, 0xb4, 0x5d, 0xef, 0x6c, 0x39,
2160 0x2d, 0x74, 0x08, 0xee, 0x82, 0x6a, 0xbf, 0x9e, 0xc4, 0xc6, 0xee, 0xc3, 0xcb, 0x8a, 0x64, 0x33,
2161 0x09, 0xfe, 0x04, 0x35, 0x04, 0x1b, 0xc1, 0xa7, 0xe3, 0x31, 0x38, 0x52, 0xb4, 0x5f, 0x49, 0x5d,
2162 0x74, 0xd5, 0x7b, 0x79, 0x52, 0xc0, 0x17, 0xb1, 0x71, 0xbb, 0x38, 0x1e, 0xba, 0x54, 0x08, 0xb2,
2163 0x4a, 0xeb, 0xfe, 0xa6, 0xa1, 0x57, 0x5f, 0xf0, 0xb3, 0x30, 0x45, 0x55, 0x91, 0x3d, 0x41, 0xf9,
2164 0xec, 0x7f, 0xb0, 0xfd, 0xaf, 0xb8, 0xfc, 0x76, 0xd9, 0x8d, 0x24, 0x36, 0xaa, 0x0b, 0x74, 0xa1,
2165 0x8b, 0x7b, 0xa8, 0xe6, 0x50, 0x3b, 0xf2, 0x47, 0xf9, 0xe3, 0xd9, 0xb4, 0x9b, 0x6a, 0x57, 0x0e,
2166 0x0f, 0x32, 0x8c, 0x2c, 0xa3, 0xf8, 0x0d, 0x54, 0x8e, 0xb8, 0x9b, 0xbf, 0x53, 0xd5, 0x24, 0x36,
2167 0xca, 0x5f, 0x91, 0x63, 0xa2, 0x30, 0xfb, 0xde, 0xd9, 0xb9, 0x5e, 0x7a, 0x76, 0xae, 0x97, 0x9e,
2168 0x9f, 0xeb, 0xa5, 0x1f, 0x12, 0x5d, 0x3b, 0x4b, 0x74, 0xed, 0x59, 0xa2, 0x6b, 0xcf, 0x13, 0x5d,
2169 0xfb, 0x33, 0xd1, 0xb5, 0x9f, 0xfe, 0xd2, 0x4b, 0x5f, 0x57, 0xf3, 0xd2, 0xfe, 0x0d, 0x00, 0x00,
2170 0xff, 0xff, 0x85, 0x06, 0x8c, 0x7f, 0xae, 0x09, 0x00, 0x00,
2171}