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