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