Blame - vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.pb.go - voltctl

blob: c8ff6e396b92d873e3e1c59de9d2ffdae7444b07 [file] [log] [blame]

Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1	/*
				2	Copyright The Kubernetes Authors.
				3
				4	Licensed under the Apache License, Version 2.0 (the "License");
				5	you may not use this file except in compliance with the License.
				6	You may obtain a copy of the License at
				7
				8	http://www.apache.org/licenses/LICENSE-2.0
				9
				10	Unless required by applicable law or agreed to in writing, software
				11	distributed under the License is distributed on an "AS IS" BASIS,
				12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
				13	See the License for the specific language governing permissions and
				14	limitations under the License.
				15	*/
				16
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	17	// Code generated by protoc-gen-gogo. DO NOT EDIT.
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	18	// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	19
				20	/*
				21	Package v1 is a generated protocol buffer package.
				22
				23	It is generated from these files:
				24	k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto
				25
				26	It has these top-level messages:
				27	APIGroup
				28	APIGroupList
				29	APIResource
				30	APIResourceList
				31	APIVersions
				32	CreateOptions
				33	DeleteOptions
				34	Duration
				35	ExportOptions
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	36	Fields
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	37	GetOptions
				38	GroupKind
				39	GroupResource
				40	GroupVersion
				41	GroupVersionForDiscovery
				42	GroupVersionKind
				43	GroupVersionResource
				44	Initializer
				45	Initializers
				46	LabelSelector
				47	LabelSelectorRequirement
				48	List
				49	ListMeta
				50	ListOptions
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	51	ManagedFieldsEntry
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	52	MicroTime
				53	ObjectMeta
				54	OwnerReference
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	55	PartialObjectMetadata
				56	PartialObjectMetadataList
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	57	Patch
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	58	PatchOptions
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	59	Preconditions
				60	RootPaths
				61	ServerAddressByClientCIDR
				62	Status
				63	StatusCause
				64	StatusDetails
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	65	TableOptions
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	66	Time
				67	Timestamp
				68	TypeMeta
				69	UpdateOptions
				70	Verbs
				71	WatchEvent
				72	*/
				73	package v1
				74
				75	import proto "github.com/gogo/protobuf/proto"
				76	import fmt "fmt"
				77	import math "math"
				78
				79	import k8s_io_apimachinery_pkg_runtime "k8s.io/apimachinery/pkg/runtime"
				80
				81	import time "time"
				82	import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
				83
				84	import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
				85
				86	import strings "strings"
				87	import reflect "reflect"
				88
				89	import io "io"
				90
				91	// Reference imports to suppress errors if they are not otherwise used.
				92	var _ = proto.Marshal
				93	var _ = fmt.Errorf
				94	var _ = math.Inf
				95	var _ = time.Kitchen
				96
				97	// This is a compile-time assertion to ensure that this generated file
				98	// is compatible with the proto package it is being compiled against.
				99	// A compilation error at this line likely means your copy of the
				100	// proto package needs to be updated.
				101	const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
				102
				103	func (m APIGroup) Reset() { m = APIGroup{} }
				104	func (*APIGroup) ProtoMessage() {}
				105	func (*APIGroup) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
				106
				107	func (m APIGroupList) Reset() { m = APIGroupList{} }
				108	func (*APIGroupList) ProtoMessage() {}
				109	func (*APIGroupList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
				110
				111	func (m APIResource) Reset() { m = APIResource{} }
				112	func (*APIResource) ProtoMessage() {}
				113	func (*APIResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
				114
				115	func (m APIResourceList) Reset() { m = APIResourceList{} }
				116	func (*APIResourceList) ProtoMessage() {}
				117	func (*APIResourceList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
				118
				119	func (m APIVersions) Reset() { m = APIVersions{} }
				120	func (*APIVersions) ProtoMessage() {}
				121	func (*APIVersions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
				122
				123	func (m CreateOptions) Reset() { m = CreateOptions{} }
				124	func (*CreateOptions) ProtoMessage() {}
				125	func (*CreateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
				126
				127	func (m DeleteOptions) Reset() { m = DeleteOptions{} }
				128	func (*DeleteOptions) ProtoMessage() {}
				129	func (*DeleteOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
				130
				131	func (m Duration) Reset() { m = Duration{} }
				132	func (*Duration) ProtoMessage() {}
				133	func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
				134
				135	func (m ExportOptions) Reset() { m = ExportOptions{} }
				136	func (*ExportOptions) ProtoMessage() {}
				137	func (*ExportOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
				138
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	139	func (m Fields) Reset() { m = Fields{} }
				140	func (*Fields) ProtoMessage() {}
				141	func (*Fields) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
				142
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	143	func (m GetOptions) Reset() { m = GetOptions{} }
				144	func (*GetOptions) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	145	func (*GetOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	146
				147	func (m GroupKind) Reset() { m = GroupKind{} }
				148	func (*GroupKind) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	149	func (*GroupKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	150
				151	func (m GroupResource) Reset() { m = GroupResource{} }
				152	func (*GroupResource) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	153	func (*GroupResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	154
				155	func (m GroupVersion) Reset() { m = GroupVersion{} }
				156	func (*GroupVersion) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	157	func (*GroupVersion) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	158
				159	func (m GroupVersionForDiscovery) Reset() { m = GroupVersionForDiscovery{} }
				160	func (*GroupVersionForDiscovery) ProtoMessage() {}
				161	func (*GroupVersionForDiscovery) Descriptor() ([]byte, []int) {
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	162	return fileDescriptorGenerated, []int{14}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	163	}
				164
				165	func (m GroupVersionKind) Reset() { m = GroupVersionKind{} }
				166	func (*GroupVersionKind) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	167	func (*GroupVersionKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	168
				169	func (m GroupVersionResource) Reset() { m = GroupVersionResource{} }
				170	func (*GroupVersionResource) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	171	func (*GroupVersionResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	172
				173	func (m Initializer) Reset() { m = Initializer{} }
				174	func (*Initializer) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	175	func (*Initializer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	176
				177	func (m Initializers) Reset() { m = Initializers{} }
				178	func (*Initializers) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	179	func (*Initializers) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	180
				181	func (m LabelSelector) Reset() { m = LabelSelector{} }
				182	func (*LabelSelector) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	183	func (*LabelSelector) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	184
				185	func (m LabelSelectorRequirement) Reset() { m = LabelSelectorRequirement{} }
				186	func (*LabelSelectorRequirement) ProtoMessage() {}
				187	func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) {
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	188	return fileDescriptorGenerated, []int{20}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	189	}
				190
				191	func (m List) Reset() { m = List{} }
				192	func (*List) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	193	func (*List) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	194
				195	func (m ListMeta) Reset() { m = ListMeta{} }
				196	func (*ListMeta) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	197	func (*ListMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	198
				199	func (m ListOptions) Reset() { m = ListOptions{} }
				200	func (*ListOptions) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	201	func (*ListOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
				202
				203	func (m ManagedFieldsEntry) Reset() { m = ManagedFieldsEntry{} }
				204	func (*ManagedFieldsEntry) ProtoMessage() {}
				205	func (*ManagedFieldsEntry) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	206
				207	func (m MicroTime) Reset() { m = MicroTime{} }
				208	func (*MicroTime) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	209	func (*MicroTime) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	210
				211	func (m ObjectMeta) Reset() { m = ObjectMeta{} }
				212	func (*ObjectMeta) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	213	func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	214
				215	func (m OwnerReference) Reset() { m = OwnerReference{} }
				216	func (*OwnerReference) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	217	func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
				218
				219	func (m PartialObjectMetadata) Reset() { m = PartialObjectMetadata{} }
				220	func (*PartialObjectMetadata) ProtoMessage() {}
				221	func (*PartialObjectMetadata) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
				222
				223	func (m PartialObjectMetadataList) Reset() { m = PartialObjectMetadataList{} }
				224	func (*PartialObjectMetadataList) ProtoMessage() {}
				225	func (*PartialObjectMetadataList) Descriptor() ([]byte, []int) {
				226	return fileDescriptorGenerated, []int{29}
				227	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	228
				229	func (m Patch) Reset() { m = Patch{} }
				230	func (*Patch) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	231	func (*Patch) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
				232
				233	func (m PatchOptions) Reset() { m = PatchOptions{} }
				234	func (*PatchOptions) ProtoMessage() {}
				235	func (*PatchOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	236
				237	func (m Preconditions) Reset() { m = Preconditions{} }
				238	func (*Preconditions) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	239	func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	240
				241	func (m RootPaths) Reset() { m = RootPaths{} }
				242	func (*RootPaths) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	243	func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	244
				245	func (m ServerAddressByClientCIDR) Reset() { m = ServerAddressByClientCIDR{} }
				246	func (*ServerAddressByClientCIDR) ProtoMessage() {}
				247	func (*ServerAddressByClientCIDR) Descriptor() ([]byte, []int) {
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	248	return fileDescriptorGenerated, []int{34}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	249	}
				250
				251	func (m Status) Reset() { m = Status{} }
				252	func (*Status) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	253	func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	254
				255	func (m StatusCause) Reset() { m = StatusCause{} }
				256	func (*StatusCause) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	257	func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	258
				259	func (m StatusDetails) Reset() { m = StatusDetails{} }
				260	func (*StatusDetails) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	261	func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
				262
				263	func (m TableOptions) Reset() { m = TableOptions{} }
				264	func (*TableOptions) ProtoMessage() {}
				265	func (*TableOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	266
				267	func (m Time) Reset() { m = Time{} }
				268	func (*Time) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	269	func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	270
				271	func (m Timestamp) Reset() { m = Timestamp{} }
				272	func (*Timestamp) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	273	func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	274
				275	func (m TypeMeta) Reset() { m = TypeMeta{} }
				276	func (*TypeMeta) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	277	func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	278
				279	func (m UpdateOptions) Reset() { m = UpdateOptions{} }
				280	func (*UpdateOptions) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	281	func (*UpdateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	282
				283	func (m Verbs) Reset() { m = Verbs{} }
				284	func (*Verbs) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	285	func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	286
				287	func (m WatchEvent) Reset() { m = WatchEvent{} }
				288	func (*WatchEvent) ProtoMessage() {}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	289	func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} }
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	290
				291	func init() {
				292	proto.RegisterType((*APIGroup)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroup")
				293	proto.RegisterType((*APIGroupList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroupList")
				294	proto.RegisterType((*APIResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResource")
				295	proto.RegisterType((*APIResourceList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResourceList")
				296	proto.RegisterType((*APIVersions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIVersions")
				297	proto.RegisterType((*CreateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.CreateOptions")
				298	proto.RegisterType((*DeleteOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.DeleteOptions")
				299	proto.RegisterType((*Duration)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Duration")
				300	proto.RegisterType((*ExportOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ExportOptions")
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	301	proto.RegisterType((*Fields)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Fields")
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	302	proto.RegisterType((*GetOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GetOptions")
				303	proto.RegisterType((*GroupKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupKind")
				304	proto.RegisterType((*GroupResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupResource")
				305	proto.RegisterType((*GroupVersion)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersion")
				306	proto.RegisterType((*GroupVersionForDiscovery)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery")
				307	proto.RegisterType((*GroupVersionKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionKind")
				308	proto.RegisterType((*GroupVersionResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionResource")
				309	proto.RegisterType((*Initializer)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializer")
				310	proto.RegisterType((*Initializers)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializers")
				311	proto.RegisterType((*LabelSelector)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector")
				312	proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement")
				313	proto.RegisterType((*List)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.List")
				314	proto.RegisterType((*ListMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta")
				315	proto.RegisterType((*ListOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListOptions")
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	316	proto.RegisterType((*ManagedFieldsEntry)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry")
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	317	proto.RegisterType((*MicroTime)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.MicroTime")
				318	proto.RegisterType((*ObjectMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta")
				319	proto.RegisterType((*OwnerReference)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.OwnerReference")
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	320	proto.RegisterType((*PartialObjectMetadata)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.PartialObjectMetadata")
				321	proto.RegisterType((*PartialObjectMetadataList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.PartialObjectMetadataList")
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	322	proto.RegisterType((*Patch)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Patch")
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	323	proto.RegisterType((*PatchOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.PatchOptions")
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	324	proto.RegisterType((*Preconditions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Preconditions")
				325	proto.RegisterType((*RootPaths)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.RootPaths")
				326	proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR")
				327	proto.RegisterType((*Status)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Status")
				328	proto.RegisterType((*StatusCause)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusCause")
				329	proto.RegisterType((*StatusDetails)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusDetails")
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	330	proto.RegisterType((*TableOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.TableOptions")
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	331	proto.RegisterType((*Time)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Time")
				332	proto.RegisterType((*Timestamp)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Timestamp")
				333	proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.TypeMeta")
				334	proto.RegisterType((*UpdateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.UpdateOptions")
				335	proto.RegisterType((*Verbs)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Verbs")
				336	proto.RegisterType((*WatchEvent)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.WatchEvent")
				337	}
				338	func (m *APIGroup) Marshal() (dAtA []byte, err error) {
				339	size := m.Size()
				340	dAtA = make([]byte, size)
				341	n, err := m.MarshalTo(dAtA)
				342	if err != nil {
				343	return nil, err
				344	}
				345	return dAtA[:n], nil
				346	}
				347
				348	func (m *APIGroup) MarshalTo(dAtA []byte) (int, error) {
				349	var i int
				350	_ = i
				351	var l int
				352	_ = l
				353	dAtA[i] = 0xa
				354	i++
				355	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				356	i += copy(dAtA[i:], m.Name)
				357	if len(m.Versions) > 0 {
				358	for _, msg := range m.Versions {
				359	dAtA[i] = 0x12
				360	i++
				361	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				362	n, err := msg.MarshalTo(dAtA[i:])
				363	if err != nil {
				364	return 0, err
				365	}
				366	i += n
				367	}
				368	}
				369	dAtA[i] = 0x1a
				370	i++
				371	i = encodeVarintGenerated(dAtA, i, uint64(m.PreferredVersion.Size()))
				372	n1, err := m.PreferredVersion.MarshalTo(dAtA[i:])
				373	if err != nil {
				374	return 0, err
				375	}
				376	i += n1
				377	if len(m.ServerAddressByClientCIDRs) > 0 {
				378	for _, msg := range m.ServerAddressByClientCIDRs {
				379	dAtA[i] = 0x22
				380	i++
				381	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				382	n, err := msg.MarshalTo(dAtA[i:])
				383	if err != nil {
				384	return 0, err
				385	}
				386	i += n
				387	}
				388	}
				389	return i, nil
				390	}
				391
				392	func (m *APIGroupList) Marshal() (dAtA []byte, err error) {
				393	size := m.Size()
				394	dAtA = make([]byte, size)
				395	n, err := m.MarshalTo(dAtA)
				396	if err != nil {
				397	return nil, err
				398	}
				399	return dAtA[:n], nil
				400	}
				401
				402	func (m *APIGroupList) MarshalTo(dAtA []byte) (int, error) {
				403	var i int
				404	_ = i
				405	var l int
				406	_ = l
				407	if len(m.Groups) > 0 {
				408	for _, msg := range m.Groups {
				409	dAtA[i] = 0xa
				410	i++
				411	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				412	n, err := msg.MarshalTo(dAtA[i:])
				413	if err != nil {
				414	return 0, err
				415	}
				416	i += n
				417	}
				418	}
				419	return i, nil
				420	}
				421
				422	func (m *APIResource) Marshal() (dAtA []byte, err error) {
				423	size := m.Size()
				424	dAtA = make([]byte, size)
				425	n, err := m.MarshalTo(dAtA)
				426	if err != nil {
				427	return nil, err
				428	}
				429	return dAtA[:n], nil
				430	}
				431
				432	func (m *APIResource) MarshalTo(dAtA []byte) (int, error) {
				433	var i int
				434	_ = i
				435	var l int
				436	_ = l
				437	dAtA[i] = 0xa
				438	i++
				439	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				440	i += copy(dAtA[i:], m.Name)
				441	dAtA[i] = 0x10
				442	i++
				443	if m.Namespaced {
				444	dAtA[i] = 1
				445	} else {
				446	dAtA[i] = 0
				447	}
				448	i++
				449	dAtA[i] = 0x1a
				450	i++
				451	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				452	i += copy(dAtA[i:], m.Kind)
				453	if m.Verbs != nil {
				454	dAtA[i] = 0x22
				455	i++
				456	i = encodeVarintGenerated(dAtA, i, uint64(m.Verbs.Size()))
				457	n2, err := m.Verbs.MarshalTo(dAtA[i:])
				458	if err != nil {
				459	return 0, err
				460	}
				461	i += n2
				462	}
				463	if len(m.ShortNames) > 0 {
				464	for _, s := range m.ShortNames {
				465	dAtA[i] = 0x2a
				466	i++
				467	l = len(s)
				468	for l >= 1<<7 {
				469	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				470	l >>= 7
				471	i++
				472	}
				473	dAtA[i] = uint8(l)
				474	i++
				475	i += copy(dAtA[i:], s)
				476	}
				477	}
				478	dAtA[i] = 0x32
				479	i++
				480	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SingularName)))
				481	i += copy(dAtA[i:], m.SingularName)
				482	if len(m.Categories) > 0 {
				483	for _, s := range m.Categories {
				484	dAtA[i] = 0x3a
				485	i++
				486	l = len(s)
				487	for l >= 1<<7 {
				488	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				489	l >>= 7
				490	i++
				491	}
				492	dAtA[i] = uint8(l)
				493	i++
				494	i += copy(dAtA[i:], s)
				495	}
				496	}
				497	dAtA[i] = 0x42
				498	i++
				499	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				500	i += copy(dAtA[i:], m.Group)
				501	dAtA[i] = 0x4a
				502	i++
				503	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
				504	i += copy(dAtA[i:], m.Version)
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	505	dAtA[i] = 0x52
				506	i++
				507	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StorageVersionHash)))
				508	i += copy(dAtA[i:], m.StorageVersionHash)
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	509	return i, nil
				510	}
				511
				512	func (m *APIResourceList) Marshal() (dAtA []byte, err error) {
				513	size := m.Size()
				514	dAtA = make([]byte, size)
				515	n, err := m.MarshalTo(dAtA)
				516	if err != nil {
				517	return nil, err
				518	}
				519	return dAtA[:n], nil
				520	}
				521
				522	func (m *APIResourceList) MarshalTo(dAtA []byte) (int, error) {
				523	var i int
				524	_ = i
				525	var l int
				526	_ = l
				527	dAtA[i] = 0xa
				528	i++
				529	i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
				530	i += copy(dAtA[i:], m.GroupVersion)
				531	if len(m.APIResources) > 0 {
				532	for _, msg := range m.APIResources {
				533	dAtA[i] = 0x12
				534	i++
				535	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				536	n, err := msg.MarshalTo(dAtA[i:])
				537	if err != nil {
				538	return 0, err
				539	}
				540	i += n
				541	}
				542	}
				543	return i, nil
				544	}
				545
				546	func (m *APIVersions) Marshal() (dAtA []byte, err error) {
				547	size := m.Size()
				548	dAtA = make([]byte, size)
				549	n, err := m.MarshalTo(dAtA)
				550	if err != nil {
				551	return nil, err
				552	}
				553	return dAtA[:n], nil
				554	}
				555
				556	func (m *APIVersions) MarshalTo(dAtA []byte) (int, error) {
				557	var i int
				558	_ = i
				559	var l int
				560	_ = l
				561	if len(m.Versions) > 0 {
				562	for _, s := range m.Versions {
				563	dAtA[i] = 0xa
				564	i++
				565	l = len(s)
				566	for l >= 1<<7 {
				567	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				568	l >>= 7
				569	i++
				570	}
				571	dAtA[i] = uint8(l)
				572	i++
				573	i += copy(dAtA[i:], s)
				574	}
				575	}
				576	if len(m.ServerAddressByClientCIDRs) > 0 {
				577	for _, msg := range m.ServerAddressByClientCIDRs {
				578	dAtA[i] = 0x12
				579	i++
				580	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				581	n, err := msg.MarshalTo(dAtA[i:])
				582	if err != nil {
				583	return 0, err
				584	}
				585	i += n
				586	}
				587	}
				588	return i, nil
				589	}
				590
				591	func (m *CreateOptions) Marshal() (dAtA []byte, err error) {
				592	size := m.Size()
				593	dAtA = make([]byte, size)
				594	n, err := m.MarshalTo(dAtA)
				595	if err != nil {
				596	return nil, err
				597	}
				598	return dAtA[:n], nil
				599	}
				600
				601	func (m *CreateOptions) MarshalTo(dAtA []byte) (int, error) {
				602	var i int
				603	_ = i
				604	var l int
				605	_ = l
				606	if len(m.DryRun) > 0 {
				607	for _, s := range m.DryRun {
				608	dAtA[i] = 0xa
				609	i++
				610	l = len(s)
				611	for l >= 1<<7 {
				612	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				613	l >>= 7
				614	i++
				615	}
				616	dAtA[i] = uint8(l)
				617	i++
				618	i += copy(dAtA[i:], s)
				619	}
				620	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	621	dAtA[i] = 0x1a
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	622	i++
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	623	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager)))
				624	i += copy(dAtA[i:], m.FieldManager)
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	625	return i, nil
				626	}
				627
				628	func (m *DeleteOptions) Marshal() (dAtA []byte, err error) {
				629	size := m.Size()
				630	dAtA = make([]byte, size)
				631	n, err := m.MarshalTo(dAtA)
				632	if err != nil {
				633	return nil, err
				634	}
				635	return dAtA[:n], nil
				636	}
				637
				638	func (m *DeleteOptions) MarshalTo(dAtA []byte) (int, error) {
				639	var i int
				640	_ = i
				641	var l int
				642	_ = l
				643	if m.GracePeriodSeconds != nil {
				644	dAtA[i] = 0x8
				645	i++
				646	i = encodeVarintGenerated(dAtA, i, uint64(*m.GracePeriodSeconds))
				647	}
				648	if m.Preconditions != nil {
				649	dAtA[i] = 0x12
				650	i++
				651	i = encodeVarintGenerated(dAtA, i, uint64(m.Preconditions.Size()))
				652	n3, err := m.Preconditions.MarshalTo(dAtA[i:])
				653	if err != nil {
				654	return 0, err
				655	}
				656	i += n3
				657	}
				658	if m.OrphanDependents != nil {
				659	dAtA[i] = 0x18
				660	i++
				661	if *m.OrphanDependents {
				662	dAtA[i] = 1
				663	} else {
				664	dAtA[i] = 0
				665	}
				666	i++
				667	}
				668	if m.PropagationPolicy != nil {
				669	dAtA[i] = 0x22
				670	i++
				671	i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PropagationPolicy)))
				672	i += copy(dAtA[i:], *m.PropagationPolicy)
				673	}
				674	if len(m.DryRun) > 0 {
				675	for _, s := range m.DryRun {
				676	dAtA[i] = 0x2a
				677	i++
				678	l = len(s)
				679	for l >= 1<<7 {
				680	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				681	l >>= 7
				682	i++
				683	}
				684	dAtA[i] = uint8(l)
				685	i++
				686	i += copy(dAtA[i:], s)
				687	}
				688	}
				689	return i, nil
				690	}
				691
				692	func (m *Duration) Marshal() (dAtA []byte, err error) {
				693	size := m.Size()
				694	dAtA = make([]byte, size)
				695	n, err := m.MarshalTo(dAtA)
				696	if err != nil {
				697	return nil, err
				698	}
				699	return dAtA[:n], nil
				700	}
				701
				702	func (m *Duration) MarshalTo(dAtA []byte) (int, error) {
				703	var i int
				704	_ = i
				705	var l int
				706	_ = l
				707	dAtA[i] = 0x8
				708	i++
				709	i = encodeVarintGenerated(dAtA, i, uint64(m.Duration))
				710	return i, nil
				711	}
				712
				713	func (m *ExportOptions) Marshal() (dAtA []byte, err error) {
				714	size := m.Size()
				715	dAtA = make([]byte, size)
				716	n, err := m.MarshalTo(dAtA)
				717	if err != nil {
				718	return nil, err
				719	}
				720	return dAtA[:n], nil
				721	}
				722
				723	func (m *ExportOptions) MarshalTo(dAtA []byte) (int, error) {
				724	var i int
				725	_ = i
				726	var l int
				727	_ = l
				728	dAtA[i] = 0x8
				729	i++
				730	if m.Export {
				731	dAtA[i] = 1
				732	} else {
				733	dAtA[i] = 0
				734	}
				735	i++
				736	dAtA[i] = 0x10
				737	i++
				738	if m.Exact {
				739	dAtA[i] = 1
				740	} else {
				741	dAtA[i] = 0
				742	}
				743	i++
				744	return i, nil
				745	}
				746
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	747	func (m *Fields) Marshal() (dAtA []byte, err error) {
				748	size := m.Size()
				749	dAtA = make([]byte, size)
				750	n, err := m.MarshalTo(dAtA)
				751	if err != nil {
				752	return nil, err
				753	}
				754	return dAtA[:n], nil
				755	}
				756
				757	func (m *Fields) MarshalTo(dAtA []byte) (int, error) {
				758	var i int
				759	_ = i
				760	var l int
				761	_ = l
				762	if len(m.Map) > 0 {
				763	keysForMap := make([]string, 0, len(m.Map))
				764	for k := range m.Map {
				765	keysForMap = append(keysForMap, string(k))
				766	}
				767	github_com_gogo_protobuf_sortkeys.Strings(keysForMap)
				768	for _, k := range keysForMap {
				769	dAtA[i] = 0xa
				770	i++
				771	v := m.Map[string(k)]
				772	msgSize := 0
				773	if (&v) != nil {
				774	msgSize = (&v).Size()
				775	msgSize += 1 + sovGenerated(uint64(msgSize))
				776	}
				777	mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
				778	i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
				779	dAtA[i] = 0xa
				780	i++
				781	i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
				782	i += copy(dAtA[i:], k)
				783	dAtA[i] = 0x12
				784	i++
				785	i = encodeVarintGenerated(dAtA, i, uint64((&v).Size()))
				786	n4, err := (&v).MarshalTo(dAtA[i:])
				787	if err != nil {
				788	return 0, err
				789	}
				790	i += n4
				791	}
				792	}
				793	return i, nil
				794	}
				795
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	796	func (m *GetOptions) Marshal() (dAtA []byte, err error) {
				797	size := m.Size()
				798	dAtA = make([]byte, size)
				799	n, err := m.MarshalTo(dAtA)
				800	if err != nil {
				801	return nil, err
				802	}
				803	return dAtA[:n], nil
				804	}
				805
				806	func (m *GetOptions) MarshalTo(dAtA []byte) (int, error) {
				807	var i int
				808	_ = i
				809	var l int
				810	_ = l
				811	dAtA[i] = 0xa
				812	i++
				813	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
				814	i += copy(dAtA[i:], m.ResourceVersion)
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	815	return i, nil
				816	}
				817
				818	func (m *GroupKind) Marshal() (dAtA []byte, err error) {
				819	size := m.Size()
				820	dAtA = make([]byte, size)
				821	n, err := m.MarshalTo(dAtA)
				822	if err != nil {
				823	return nil, err
				824	}
				825	return dAtA[:n], nil
				826	}
				827
				828	func (m *GroupKind) MarshalTo(dAtA []byte) (int, error) {
				829	var i int
				830	_ = i
				831	var l int
				832	_ = l
				833	dAtA[i] = 0xa
				834	i++
				835	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				836	i += copy(dAtA[i:], m.Group)
				837	dAtA[i] = 0x12
				838	i++
				839	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				840	i += copy(dAtA[i:], m.Kind)
				841	return i, nil
				842	}
				843
				844	func (m *GroupResource) Marshal() (dAtA []byte, err error) {
				845	size := m.Size()
				846	dAtA = make([]byte, size)
				847	n, err := m.MarshalTo(dAtA)
				848	if err != nil {
				849	return nil, err
				850	}
				851	return dAtA[:n], nil
				852	}
				853
				854	func (m *GroupResource) MarshalTo(dAtA []byte) (int, error) {
				855	var i int
				856	_ = i
				857	var l int
				858	_ = l
				859	dAtA[i] = 0xa
				860	i++
				861	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				862	i += copy(dAtA[i:], m.Group)
				863	dAtA[i] = 0x12
				864	i++
				865	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
				866	i += copy(dAtA[i:], m.Resource)
				867	return i, nil
				868	}
				869
				870	func (m *GroupVersion) Marshal() (dAtA []byte, err error) {
				871	size := m.Size()
				872	dAtA = make([]byte, size)
				873	n, err := m.MarshalTo(dAtA)
				874	if err != nil {
				875	return nil, err
				876	}
				877	return dAtA[:n], nil
				878	}
				879
				880	func (m *GroupVersion) MarshalTo(dAtA []byte) (int, error) {
				881	var i int
				882	_ = i
				883	var l int
				884	_ = l
				885	dAtA[i] = 0xa
				886	i++
				887	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				888	i += copy(dAtA[i:], m.Group)
				889	dAtA[i] = 0x12
				890	i++
				891	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
				892	i += copy(dAtA[i:], m.Version)
				893	return i, nil
				894	}
				895
				896	func (m *GroupVersionForDiscovery) Marshal() (dAtA []byte, err error) {
				897	size := m.Size()
				898	dAtA = make([]byte, size)
				899	n, err := m.MarshalTo(dAtA)
				900	if err != nil {
				901	return nil, err
				902	}
				903	return dAtA[:n], nil
				904	}
				905
				906	func (m *GroupVersionForDiscovery) MarshalTo(dAtA []byte) (int, error) {
				907	var i int
				908	_ = i
				909	var l int
				910	_ = l
				911	dAtA[i] = 0xa
				912	i++
				913	i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
				914	i += copy(dAtA[i:], m.GroupVersion)
				915	dAtA[i] = 0x12
				916	i++
				917	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
				918	i += copy(dAtA[i:], m.Version)
				919	return i, nil
				920	}
				921
				922	func (m *GroupVersionKind) Marshal() (dAtA []byte, err error) {
				923	size := m.Size()
				924	dAtA = make([]byte, size)
				925	n, err := m.MarshalTo(dAtA)
				926	if err != nil {
				927	return nil, err
				928	}
				929	return dAtA[:n], nil
				930	}
				931
				932	func (m *GroupVersionKind) MarshalTo(dAtA []byte) (int, error) {
				933	var i int
				934	_ = i
				935	var l int
				936	_ = l
				937	dAtA[i] = 0xa
				938	i++
				939	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				940	i += copy(dAtA[i:], m.Group)
				941	dAtA[i] = 0x12
				942	i++
				943	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
				944	i += copy(dAtA[i:], m.Version)
				945	dAtA[i] = 0x1a
				946	i++
				947	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				948	i += copy(dAtA[i:], m.Kind)
				949	return i, nil
				950	}
				951
				952	func (m *GroupVersionResource) Marshal() (dAtA []byte, err error) {
				953	size := m.Size()
				954	dAtA = make([]byte, size)
				955	n, err := m.MarshalTo(dAtA)
				956	if err != nil {
				957	return nil, err
				958	}
				959	return dAtA[:n], nil
				960	}
				961
				962	func (m *GroupVersionResource) MarshalTo(dAtA []byte) (int, error) {
				963	var i int
				964	_ = i
				965	var l int
				966	_ = l
				967	dAtA[i] = 0xa
				968	i++
				969	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				970	i += copy(dAtA[i:], m.Group)
				971	dAtA[i] = 0x12
				972	i++
				973	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
				974	i += copy(dAtA[i:], m.Version)
				975	dAtA[i] = 0x1a
				976	i++
				977	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
				978	i += copy(dAtA[i:], m.Resource)
				979	return i, nil
				980	}
				981
				982	func (m *Initializer) Marshal() (dAtA []byte, err error) {
				983	size := m.Size()
				984	dAtA = make([]byte, size)
				985	n, err := m.MarshalTo(dAtA)
				986	if err != nil {
				987	return nil, err
				988	}
				989	return dAtA[:n], nil
				990	}
				991
				992	func (m *Initializer) MarshalTo(dAtA []byte) (int, error) {
				993	var i int
				994	_ = i
				995	var l int
				996	_ = l
				997	dAtA[i] = 0xa
				998	i++
				999	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				1000	i += copy(dAtA[i:], m.Name)
				1001	return i, nil
				1002	}
				1003
				1004	func (m *Initializers) Marshal() (dAtA []byte, err error) {
				1005	size := m.Size()
				1006	dAtA = make([]byte, size)
				1007	n, err := m.MarshalTo(dAtA)
				1008	if err != nil {
				1009	return nil, err
				1010	}
				1011	return dAtA[:n], nil
				1012	}
				1013
				1014	func (m *Initializers) MarshalTo(dAtA []byte) (int, error) {
				1015	var i int
				1016	_ = i
				1017	var l int
				1018	_ = l
				1019	if len(m.Pending) > 0 {
				1020	for _, msg := range m.Pending {
				1021	dAtA[i] = 0xa
				1022	i++
				1023	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1024	n, err := msg.MarshalTo(dAtA[i:])
				1025	if err != nil {
				1026	return 0, err
				1027	}
				1028	i += n
				1029	}
				1030	}
				1031	if m.Result != nil {
				1032	dAtA[i] = 0x12
				1033	i++
				1034	i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1035	n5, err := m.Result.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1036	if err != nil {
				1037	return 0, err
				1038	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1039	i += n5
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1040	}
				1041	return i, nil
				1042	}
				1043
				1044	func (m *LabelSelector) Marshal() (dAtA []byte, err error) {
				1045	size := m.Size()
				1046	dAtA = make([]byte, size)
				1047	n, err := m.MarshalTo(dAtA)
				1048	if err != nil {
				1049	return nil, err
				1050	}
				1051	return dAtA[:n], nil
				1052	}
				1053
				1054	func (m *LabelSelector) MarshalTo(dAtA []byte) (int, error) {
				1055	var i int
				1056	_ = i
				1057	var l int
				1058	_ = l
				1059	if len(m.MatchLabels) > 0 {
				1060	keysForMatchLabels := make([]string, 0, len(m.MatchLabels))
				1061	for k := range m.MatchLabels {
				1062	keysForMatchLabels = append(keysForMatchLabels, string(k))
				1063	}
				1064	github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
				1065	for _, k := range keysForMatchLabels {
				1066	dAtA[i] = 0xa
				1067	i++
				1068	v := m.MatchLabels[string(k)]
				1069	mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				1070	i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
				1071	dAtA[i] = 0xa
				1072	i++
				1073	i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
				1074	i += copy(dAtA[i:], k)
				1075	dAtA[i] = 0x12
				1076	i++
				1077	i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
				1078	i += copy(dAtA[i:], v)
				1079	}
				1080	}
				1081	if len(m.MatchExpressions) > 0 {
				1082	for _, msg := range m.MatchExpressions {
				1083	dAtA[i] = 0x12
				1084	i++
				1085	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1086	n, err := msg.MarshalTo(dAtA[i:])
				1087	if err != nil {
				1088	return 0, err
				1089	}
				1090	i += n
				1091	}
				1092	}
				1093	return i, nil
				1094	}
				1095
				1096	func (m *LabelSelectorRequirement) Marshal() (dAtA []byte, err error) {
				1097	size := m.Size()
				1098	dAtA = make([]byte, size)
				1099	n, err := m.MarshalTo(dAtA)
				1100	if err != nil {
				1101	return nil, err
				1102	}
				1103	return dAtA[:n], nil
				1104	}
				1105
				1106	func (m *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) {
				1107	var i int
				1108	_ = i
				1109	var l int
				1110	_ = l
				1111	dAtA[i] = 0xa
				1112	i++
				1113	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
				1114	i += copy(dAtA[i:], m.Key)
				1115	dAtA[i] = 0x12
				1116	i++
				1117	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator)))
				1118	i += copy(dAtA[i:], m.Operator)
				1119	if len(m.Values) > 0 {
				1120	for _, s := range m.Values {
				1121	dAtA[i] = 0x1a
				1122	i++
				1123	l = len(s)
				1124	for l >= 1<<7 {
				1125	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				1126	l >>= 7
				1127	i++
				1128	}
				1129	dAtA[i] = uint8(l)
				1130	i++
				1131	i += copy(dAtA[i:], s)
				1132	}
				1133	}
				1134	return i, nil
				1135	}
				1136
				1137	func (m *List) Marshal() (dAtA []byte, err error) {
				1138	size := m.Size()
				1139	dAtA = make([]byte, size)
				1140	n, err := m.MarshalTo(dAtA)
				1141	if err != nil {
				1142	return nil, err
				1143	}
				1144	return dAtA[:n], nil
				1145	}
				1146
				1147	func (m *List) MarshalTo(dAtA []byte) (int, error) {
				1148	var i int
				1149	_ = i
				1150	var l int
				1151	_ = l
				1152	dAtA[i] = 0xa
				1153	i++
				1154	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1155	n6, err := m.ListMeta.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1156	if err != nil {
				1157	return 0, err
				1158	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1159	i += n6
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1160	if len(m.Items) > 0 {
				1161	for _, msg := range m.Items {
				1162	dAtA[i] = 0x12
				1163	i++
				1164	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1165	n, err := msg.MarshalTo(dAtA[i:])
				1166	if err != nil {
				1167	return 0, err
				1168	}
				1169	i += n
				1170	}
				1171	}
				1172	return i, nil
				1173	}
				1174
				1175	func (m *ListMeta) Marshal() (dAtA []byte, err error) {
				1176	size := m.Size()
				1177	dAtA = make([]byte, size)
				1178	n, err := m.MarshalTo(dAtA)
				1179	if err != nil {
				1180	return nil, err
				1181	}
				1182	return dAtA[:n], nil
				1183	}
				1184
				1185	func (m *ListMeta) MarshalTo(dAtA []byte) (int, error) {
				1186	var i int
				1187	_ = i
				1188	var l int
				1189	_ = l
				1190	dAtA[i] = 0xa
				1191	i++
				1192	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
				1193	i += copy(dAtA[i:], m.SelfLink)
				1194	dAtA[i] = 0x12
				1195	i++
				1196	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
				1197	i += copy(dAtA[i:], m.ResourceVersion)
				1198	dAtA[i] = 0x1a
				1199	i++
				1200	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
				1201	i += copy(dAtA[i:], m.Continue)
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1202	if m.RemainingItemCount != nil {
				1203	dAtA[i] = 0x20
				1204	i++
				1205	i = encodeVarintGenerated(dAtA, i, uint64(*m.RemainingItemCount))
				1206	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1207	return i, nil
				1208	}
				1209
				1210	func (m *ListOptions) Marshal() (dAtA []byte, err error) {
				1211	size := m.Size()
				1212	dAtA = make([]byte, size)
				1213	n, err := m.MarshalTo(dAtA)
				1214	if err != nil {
				1215	return nil, err
				1216	}
				1217	return dAtA[:n], nil
				1218	}
				1219
				1220	func (m *ListOptions) MarshalTo(dAtA []byte) (int, error) {
				1221	var i int
				1222	_ = i
				1223	var l int
				1224	_ = l
				1225	dAtA[i] = 0xa
				1226	i++
				1227	i = encodeVarintGenerated(dAtA, i, uint64(len(m.LabelSelector)))
				1228	i += copy(dAtA[i:], m.LabelSelector)
				1229	dAtA[i] = 0x12
				1230	i++
				1231	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldSelector)))
				1232	i += copy(dAtA[i:], m.FieldSelector)
				1233	dAtA[i] = 0x18
				1234	i++
				1235	if m.Watch {
				1236	dAtA[i] = 1
				1237	} else {
				1238	dAtA[i] = 0
				1239	}
				1240	i++
				1241	dAtA[i] = 0x22
				1242	i++
				1243	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
				1244	i += copy(dAtA[i:], m.ResourceVersion)
				1245	if m.TimeoutSeconds != nil {
				1246	dAtA[i] = 0x28
				1247	i++
				1248	i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
				1249	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1250	dAtA[i] = 0x38
				1251	i++
				1252	i = encodeVarintGenerated(dAtA, i, uint64(m.Limit))
				1253	dAtA[i] = 0x42
				1254	i++
				1255	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
				1256	i += copy(dAtA[i:], m.Continue)
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1257	dAtA[i] = 0x48
				1258	i++
				1259	if m.AllowWatchBookmarks {
				1260	dAtA[i] = 1
				1261	} else {
				1262	dAtA[i] = 0
				1263	}
				1264	i++
				1265	return i, nil
				1266	}
				1267
				1268	func (m *ManagedFieldsEntry) Marshal() (dAtA []byte, err error) {
				1269	size := m.Size()
				1270	dAtA = make([]byte, size)
				1271	n, err := m.MarshalTo(dAtA)
				1272	if err != nil {
				1273	return nil, err
				1274	}
				1275	return dAtA[:n], nil
				1276	}
				1277
				1278	func (m *ManagedFieldsEntry) MarshalTo(dAtA []byte) (int, error) {
				1279	var i int
				1280	_ = i
				1281	var l int
				1282	_ = l
				1283	dAtA[i] = 0xa
				1284	i++
				1285	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Manager)))
				1286	i += copy(dAtA[i:], m.Manager)
				1287	dAtA[i] = 0x12
				1288	i++
				1289	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operation)))
				1290	i += copy(dAtA[i:], m.Operation)
				1291	dAtA[i] = 0x1a
				1292	i++
				1293	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
				1294	i += copy(dAtA[i:], m.APIVersion)
				1295	if m.Time != nil {
				1296	dAtA[i] = 0x22
				1297	i++
				1298	i = encodeVarintGenerated(dAtA, i, uint64(m.Time.Size()))
				1299	n7, err := m.Time.MarshalTo(dAtA[i:])
				1300	if err != nil {
				1301	return 0, err
				1302	}
				1303	i += n7
				1304	}
				1305	if m.Fields != nil {
				1306	dAtA[i] = 0x2a
				1307	i++
				1308	i = encodeVarintGenerated(dAtA, i, uint64(m.Fields.Size()))
				1309	n8, err := m.Fields.MarshalTo(dAtA[i:])
				1310	if err != nil {
				1311	return 0, err
				1312	}
				1313	i += n8
				1314	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1315	return i, nil
				1316	}
				1317
				1318	func (m *ObjectMeta) Marshal() (dAtA []byte, err error) {
				1319	size := m.Size()
				1320	dAtA = make([]byte, size)
				1321	n, err := m.MarshalTo(dAtA)
				1322	if err != nil {
				1323	return nil, err
				1324	}
				1325	return dAtA[:n], nil
				1326	}
				1327
				1328	func (m *ObjectMeta) MarshalTo(dAtA []byte) (int, error) {
				1329	var i int
				1330	_ = i
				1331	var l int
				1332	_ = l
				1333	dAtA[i] = 0xa
				1334	i++
				1335	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				1336	i += copy(dAtA[i:], m.Name)
				1337	dAtA[i] = 0x12
				1338	i++
				1339	i = encodeVarintGenerated(dAtA, i, uint64(len(m.GenerateName)))
				1340	i += copy(dAtA[i:], m.GenerateName)
				1341	dAtA[i] = 0x1a
				1342	i++
				1343	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
				1344	i += copy(dAtA[i:], m.Namespace)
				1345	dAtA[i] = 0x22
				1346	i++
				1347	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
				1348	i += copy(dAtA[i:], m.SelfLink)
				1349	dAtA[i] = 0x2a
				1350	i++
				1351	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
				1352	i += copy(dAtA[i:], m.UID)
				1353	dAtA[i] = 0x32
				1354	i++
				1355	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
				1356	i += copy(dAtA[i:], m.ResourceVersion)
				1357	dAtA[i] = 0x38
				1358	i++
				1359	i = encodeVarintGenerated(dAtA, i, uint64(m.Generation))
				1360	dAtA[i] = 0x42
				1361	i++
				1362	i = encodeVarintGenerated(dAtA, i, uint64(m.CreationTimestamp.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1363	n9, err := m.CreationTimestamp.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1364	if err != nil {
				1365	return 0, err
				1366	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1367	i += n9
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1368	if m.DeletionTimestamp != nil {
				1369	dAtA[i] = 0x4a
				1370	i++
				1371	i = encodeVarintGenerated(dAtA, i, uint64(m.DeletionTimestamp.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1372	n10, err := m.DeletionTimestamp.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1373	if err != nil {
				1374	return 0, err
				1375	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1376	i += n10
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1377	}
				1378	if m.DeletionGracePeriodSeconds != nil {
				1379	dAtA[i] = 0x50
				1380	i++
				1381	i = encodeVarintGenerated(dAtA, i, uint64(*m.DeletionGracePeriodSeconds))
				1382	}
				1383	if len(m.Labels) > 0 {
				1384	keysForLabels := make([]string, 0, len(m.Labels))
				1385	for k := range m.Labels {
				1386	keysForLabels = append(keysForLabels, string(k))
				1387	}
				1388	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
				1389	for _, k := range keysForLabels {
				1390	dAtA[i] = 0x5a
				1391	i++
				1392	v := m.Labels[string(k)]
				1393	mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				1394	i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
				1395	dAtA[i] = 0xa
				1396	i++
				1397	i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
				1398	i += copy(dAtA[i:], k)
				1399	dAtA[i] = 0x12
				1400	i++
				1401	i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
				1402	i += copy(dAtA[i:], v)
				1403	}
				1404	}
				1405	if len(m.Annotations) > 0 {
				1406	keysForAnnotations := make([]string, 0, len(m.Annotations))
				1407	for k := range m.Annotations {
				1408	keysForAnnotations = append(keysForAnnotations, string(k))
				1409	}
				1410	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
				1411	for _, k := range keysForAnnotations {
				1412	dAtA[i] = 0x62
				1413	i++
				1414	v := m.Annotations[string(k)]
				1415	mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				1416	i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
				1417	dAtA[i] = 0xa
				1418	i++
				1419	i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
				1420	i += copy(dAtA[i:], k)
				1421	dAtA[i] = 0x12
				1422	i++
				1423	i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
				1424	i += copy(dAtA[i:], v)
				1425	}
				1426	}
				1427	if len(m.OwnerReferences) > 0 {
				1428	for _, msg := range m.OwnerReferences {
				1429	dAtA[i] = 0x6a
				1430	i++
				1431	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1432	n, err := msg.MarshalTo(dAtA[i:])
				1433	if err != nil {
				1434	return 0, err
				1435	}
				1436	i += n
				1437	}
				1438	}
				1439	if len(m.Finalizers) > 0 {
				1440	for _, s := range m.Finalizers {
				1441	dAtA[i] = 0x72
				1442	i++
				1443	l = len(s)
				1444	for l >= 1<<7 {
				1445	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				1446	l >>= 7
				1447	i++
				1448	}
				1449	dAtA[i] = uint8(l)
				1450	i++
				1451	i += copy(dAtA[i:], s)
				1452	}
				1453	}
				1454	dAtA[i] = 0x7a
				1455	i++
				1456	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterName)))
				1457	i += copy(dAtA[i:], m.ClusterName)
				1458	if m.Initializers != nil {
				1459	dAtA[i] = 0x82
				1460	i++
				1461	dAtA[i] = 0x1
				1462	i++
				1463	i = encodeVarintGenerated(dAtA, i, uint64(m.Initializers.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1464	n11, err := m.Initializers.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1465	if err != nil {
				1466	return 0, err
				1467	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1468	i += n11
				1469	}
				1470	if len(m.ManagedFields) > 0 {
				1471	for _, msg := range m.ManagedFields {
				1472	dAtA[i] = 0x8a
				1473	i++
				1474	dAtA[i] = 0x1
				1475	i++
				1476	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1477	n, err := msg.MarshalTo(dAtA[i:])
				1478	if err != nil {
				1479	return 0, err
				1480	}
				1481	i += n
				1482	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1483	}
				1484	return i, nil
				1485	}
				1486
				1487	func (m *OwnerReference) Marshal() (dAtA []byte, err error) {
				1488	size := m.Size()
				1489	dAtA = make([]byte, size)
				1490	n, err := m.MarshalTo(dAtA)
				1491	if err != nil {
				1492	return nil, err
				1493	}
				1494	return dAtA[:n], nil
				1495	}
				1496
				1497	func (m *OwnerReference) MarshalTo(dAtA []byte) (int, error) {
				1498	var i int
				1499	_ = i
				1500	var l int
				1501	_ = l
				1502	dAtA[i] = 0xa
				1503	i++
				1504	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				1505	i += copy(dAtA[i:], m.Kind)
				1506	dAtA[i] = 0x1a
				1507	i++
				1508	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				1509	i += copy(dAtA[i:], m.Name)
				1510	dAtA[i] = 0x22
				1511	i++
				1512	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
				1513	i += copy(dAtA[i:], m.UID)
				1514	dAtA[i] = 0x2a
				1515	i++
				1516	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
				1517	i += copy(dAtA[i:], m.APIVersion)
				1518	if m.Controller != nil {
				1519	dAtA[i] = 0x30
				1520	i++
				1521	if *m.Controller {
				1522	dAtA[i] = 1
				1523	} else {
				1524	dAtA[i] = 0
				1525	}
				1526	i++
				1527	}
				1528	if m.BlockOwnerDeletion != nil {
				1529	dAtA[i] = 0x38
				1530	i++
				1531	if *m.BlockOwnerDeletion {
				1532	dAtA[i] = 1
				1533	} else {
				1534	dAtA[i] = 0
				1535	}
				1536	i++
				1537	}
				1538	return i, nil
				1539	}
				1540
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1541	func (m *PartialObjectMetadata) Marshal() (dAtA []byte, err error) {
				1542	size := m.Size()
				1543	dAtA = make([]byte, size)
				1544	n, err := m.MarshalTo(dAtA)
				1545	if err != nil {
				1546	return nil, err
				1547	}
				1548	return dAtA[:n], nil
				1549	}
				1550
				1551	func (m *PartialObjectMetadata) MarshalTo(dAtA []byte) (int, error) {
				1552	var i int
				1553	_ = i
				1554	var l int
				1555	_ = l
				1556	dAtA[i] = 0xa
				1557	i++
				1558	i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
				1559	n12, err := m.ObjectMeta.MarshalTo(dAtA[i:])
				1560	if err != nil {
				1561	return 0, err
				1562	}
				1563	i += n12
				1564	return i, nil
				1565	}
				1566
				1567	func (m *PartialObjectMetadataList) Marshal() (dAtA []byte, err error) {
				1568	size := m.Size()
				1569	dAtA = make([]byte, size)
				1570	n, err := m.MarshalTo(dAtA)
				1571	if err != nil {
				1572	return nil, err
				1573	}
				1574	return dAtA[:n], nil
				1575	}
				1576
				1577	func (m *PartialObjectMetadataList) MarshalTo(dAtA []byte) (int, error) {
				1578	var i int
				1579	_ = i
				1580	var l int
				1581	_ = l
				1582	dAtA[i] = 0xa
				1583	i++
				1584	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
				1585	n13, err := m.ListMeta.MarshalTo(dAtA[i:])
				1586	if err != nil {
				1587	return 0, err
				1588	}
				1589	i += n13
				1590	if len(m.Items) > 0 {
				1591	for _, msg := range m.Items {
				1592	dAtA[i] = 0x12
				1593	i++
				1594	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1595	n, err := msg.MarshalTo(dAtA[i:])
				1596	if err != nil {
				1597	return 0, err
				1598	}
				1599	i += n
				1600	}
				1601	}
				1602	return i, nil
				1603	}
				1604
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1605	func (m *Patch) Marshal() (dAtA []byte, err error) {
				1606	size := m.Size()
				1607	dAtA = make([]byte, size)
				1608	n, err := m.MarshalTo(dAtA)
				1609	if err != nil {
				1610	return nil, err
				1611	}
				1612	return dAtA[:n], nil
				1613	}
				1614
				1615	func (m *Patch) MarshalTo(dAtA []byte) (int, error) {
				1616	var i int
				1617	_ = i
				1618	var l int
				1619	_ = l
				1620	return i, nil
				1621	}
				1622
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1623	func (m *PatchOptions) Marshal() (dAtA []byte, err error) {
				1624	size := m.Size()
				1625	dAtA = make([]byte, size)
				1626	n, err := m.MarshalTo(dAtA)
				1627	if err != nil {
				1628	return nil, err
				1629	}
				1630	return dAtA[:n], nil
				1631	}
				1632
				1633	func (m *PatchOptions) MarshalTo(dAtA []byte) (int, error) {
				1634	var i int
				1635	_ = i
				1636	var l int
				1637	_ = l
				1638	if len(m.DryRun) > 0 {
				1639	for _, s := range m.DryRun {
				1640	dAtA[i] = 0xa
				1641	i++
				1642	l = len(s)
				1643	for l >= 1<<7 {
				1644	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				1645	l >>= 7
				1646	i++
				1647	}
				1648	dAtA[i] = uint8(l)
				1649	i++
				1650	i += copy(dAtA[i:], s)
				1651	}
				1652	}
				1653	if m.Force != nil {
				1654	dAtA[i] = 0x10
				1655	i++
				1656	if *m.Force {
				1657	dAtA[i] = 1
				1658	} else {
				1659	dAtA[i] = 0
				1660	}
				1661	i++
				1662	}
				1663	dAtA[i] = 0x1a
				1664	i++
				1665	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager)))
				1666	i += copy(dAtA[i:], m.FieldManager)
				1667	return i, nil
				1668	}
				1669
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1670	func (m *Preconditions) Marshal() (dAtA []byte, err error) {
				1671	size := m.Size()
				1672	dAtA = make([]byte, size)
				1673	n, err := m.MarshalTo(dAtA)
				1674	if err != nil {
				1675	return nil, err
				1676	}
				1677	return dAtA[:n], nil
				1678	}
				1679
				1680	func (m *Preconditions) MarshalTo(dAtA []byte) (int, error) {
				1681	var i int
				1682	_ = i
				1683	var l int
				1684	_ = l
				1685	if m.UID != nil {
				1686	dAtA[i] = 0xa
				1687	i++
				1688	i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UID)))
				1689	i += copy(dAtA[i:], *m.UID)
				1690	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1691	if m.ResourceVersion != nil {
				1692	dAtA[i] = 0x12
				1693	i++
				1694	i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ResourceVersion)))
				1695	i += copy(dAtA[i:], *m.ResourceVersion)
				1696	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1697	return i, nil
				1698	}
				1699
				1700	func (m *RootPaths) Marshal() (dAtA []byte, err error) {
				1701	size := m.Size()
				1702	dAtA = make([]byte, size)
				1703	n, err := m.MarshalTo(dAtA)
				1704	if err != nil {
				1705	return nil, err
				1706	}
				1707	return dAtA[:n], nil
				1708	}
				1709
				1710	func (m *RootPaths) MarshalTo(dAtA []byte) (int, error) {
				1711	var i int
				1712	_ = i
				1713	var l int
				1714	_ = l
				1715	if len(m.Paths) > 0 {
				1716	for _, s := range m.Paths {
				1717	dAtA[i] = 0xa
				1718	i++
				1719	l = len(s)
				1720	for l >= 1<<7 {
				1721	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				1722	l >>= 7
				1723	i++
				1724	}
				1725	dAtA[i] = uint8(l)
				1726	i++
				1727	i += copy(dAtA[i:], s)
				1728	}
				1729	}
				1730	return i, nil
				1731	}
				1732
				1733	func (m *ServerAddressByClientCIDR) Marshal() (dAtA []byte, err error) {
				1734	size := m.Size()
				1735	dAtA = make([]byte, size)
				1736	n, err := m.MarshalTo(dAtA)
				1737	if err != nil {
				1738	return nil, err
				1739	}
				1740	return dAtA[:n], nil
				1741	}
				1742
				1743	func (m *ServerAddressByClientCIDR) MarshalTo(dAtA []byte) (int, error) {
				1744	var i int
				1745	_ = i
				1746	var l int
				1747	_ = l
				1748	dAtA[i] = 0xa
				1749	i++
				1750	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientCIDR)))
				1751	i += copy(dAtA[i:], m.ClientCIDR)
				1752	dAtA[i] = 0x12
				1753	i++
				1754	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServerAddress)))
				1755	i += copy(dAtA[i:], m.ServerAddress)
				1756	return i, nil
				1757	}
				1758
				1759	func (m *Status) Marshal() (dAtA []byte, err error) {
				1760	size := m.Size()
				1761	dAtA = make([]byte, size)
				1762	n, err := m.MarshalTo(dAtA)
				1763	if err != nil {
				1764	return nil, err
				1765	}
				1766	return dAtA[:n], nil
				1767	}
				1768
				1769	func (m *Status) MarshalTo(dAtA []byte) (int, error) {
				1770	var i int
				1771	_ = i
				1772	var l int
				1773	_ = l
				1774	dAtA[i] = 0xa
				1775	i++
				1776	i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1777	n14, err := m.ListMeta.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1778	if err != nil {
				1779	return 0, err
				1780	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1781	i += n14
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1782	dAtA[i] = 0x12
				1783	i++
				1784	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
				1785	i += copy(dAtA[i:], m.Status)
				1786	dAtA[i] = 0x1a
				1787	i++
				1788	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
				1789	i += copy(dAtA[i:], m.Message)
				1790	dAtA[i] = 0x22
				1791	i++
				1792	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
				1793	i += copy(dAtA[i:], m.Reason)
				1794	if m.Details != nil {
				1795	dAtA[i] = 0x2a
				1796	i++
				1797	i = encodeVarintGenerated(dAtA, i, uint64(m.Details.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1798	n15, err := m.Details.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1799	if err != nil {
				1800	return 0, err
				1801	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1802	i += n15
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1803	}
				1804	dAtA[i] = 0x30
				1805	i++
				1806	i = encodeVarintGenerated(dAtA, i, uint64(m.Code))
				1807	return i, nil
				1808	}
				1809
				1810	func (m *StatusCause) Marshal() (dAtA []byte, err error) {
				1811	size := m.Size()
				1812	dAtA = make([]byte, size)
				1813	n, err := m.MarshalTo(dAtA)
				1814	if err != nil {
				1815	return nil, err
				1816	}
				1817	return dAtA[:n], nil
				1818	}
				1819
				1820	func (m *StatusCause) MarshalTo(dAtA []byte) (int, error) {
				1821	var i int
				1822	_ = i
				1823	var l int
				1824	_ = l
				1825	dAtA[i] = 0xa
				1826	i++
				1827	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
				1828	i += copy(dAtA[i:], m.Type)
				1829	dAtA[i] = 0x12
				1830	i++
				1831	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
				1832	i += copy(dAtA[i:], m.Message)
				1833	dAtA[i] = 0x1a
				1834	i++
				1835	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Field)))
				1836	i += copy(dAtA[i:], m.Field)
				1837	return i, nil
				1838	}
				1839
				1840	func (m *StatusDetails) Marshal() (dAtA []byte, err error) {
				1841	size := m.Size()
				1842	dAtA = make([]byte, size)
				1843	n, err := m.MarshalTo(dAtA)
				1844	if err != nil {
				1845	return nil, err
				1846	}
				1847	return dAtA[:n], nil
				1848	}
				1849
				1850	func (m *StatusDetails) MarshalTo(dAtA []byte) (int, error) {
				1851	var i int
				1852	_ = i
				1853	var l int
				1854	_ = l
				1855	dAtA[i] = 0xa
				1856	i++
				1857	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
				1858	i += copy(dAtA[i:], m.Name)
				1859	dAtA[i] = 0x12
				1860	i++
				1861	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
				1862	i += copy(dAtA[i:], m.Group)
				1863	dAtA[i] = 0x1a
				1864	i++
				1865	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				1866	i += copy(dAtA[i:], m.Kind)
				1867	if len(m.Causes) > 0 {
				1868	for _, msg := range m.Causes {
				1869	dAtA[i] = 0x22
				1870	i++
				1871	i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
				1872	n, err := msg.MarshalTo(dAtA[i:])
				1873	if err != nil {
				1874	return 0, err
				1875	}
				1876	i += n
				1877	}
				1878	}
				1879	dAtA[i] = 0x28
				1880	i++
				1881	i = encodeVarintGenerated(dAtA, i, uint64(m.RetryAfterSeconds))
				1882	dAtA[i] = 0x32
				1883	i++
				1884	i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
				1885	i += copy(dAtA[i:], m.UID)
				1886	return i, nil
				1887	}
				1888
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1889	func (m *TableOptions) Marshal() (dAtA []byte, err error) {
				1890	size := m.Size()
				1891	dAtA = make([]byte, size)
				1892	n, err := m.MarshalTo(dAtA)
				1893	if err != nil {
				1894	return nil, err
				1895	}
				1896	return dAtA[:n], nil
				1897	}
				1898
				1899	func (m *TableOptions) MarshalTo(dAtA []byte) (int, error) {
				1900	var i int
				1901	_ = i
				1902	var l int
				1903	_ = l
				1904	dAtA[i] = 0xa
				1905	i++
				1906	i = encodeVarintGenerated(dAtA, i, uint64(len(m.IncludeObject)))
				1907	i += copy(dAtA[i:], m.IncludeObject)
				1908	return i, nil
				1909	}
				1910
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1911	func (m *Timestamp) Marshal() (dAtA []byte, err error) {
				1912	size := m.Size()
				1913	dAtA = make([]byte, size)
				1914	n, err := m.MarshalTo(dAtA)
				1915	if err != nil {
				1916	return nil, err
				1917	}
				1918	return dAtA[:n], nil
				1919	}
				1920
				1921	func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
				1922	var i int
				1923	_ = i
				1924	var l int
				1925	_ = l
				1926	dAtA[i] = 0x8
				1927	i++
				1928	i = encodeVarintGenerated(dAtA, i, uint64(m.Seconds))
				1929	dAtA[i] = 0x10
				1930	i++
				1931	i = encodeVarintGenerated(dAtA, i, uint64(m.Nanos))
				1932	return i, nil
				1933	}
				1934
				1935	func (m *TypeMeta) Marshal() (dAtA []byte, err error) {
				1936	size := m.Size()
				1937	dAtA = make([]byte, size)
				1938	n, err := m.MarshalTo(dAtA)
				1939	if err != nil {
				1940	return nil, err
				1941	}
				1942	return dAtA[:n], nil
				1943	}
				1944
				1945	func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) {
				1946	var i int
				1947	_ = i
				1948	var l int
				1949	_ = l
				1950	dAtA[i] = 0xa
				1951	i++
				1952	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
				1953	i += copy(dAtA[i:], m.Kind)
				1954	dAtA[i] = 0x12
				1955	i++
				1956	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
				1957	i += copy(dAtA[i:], m.APIVersion)
				1958	return i, nil
				1959	}
				1960
				1961	func (m *UpdateOptions) Marshal() (dAtA []byte, err error) {
				1962	size := m.Size()
				1963	dAtA = make([]byte, size)
				1964	n, err := m.MarshalTo(dAtA)
				1965	if err != nil {
				1966	return nil, err
				1967	}
				1968	return dAtA[:n], nil
				1969	}
				1970
				1971	func (m *UpdateOptions) MarshalTo(dAtA []byte) (int, error) {
				1972	var i int
				1973	_ = i
				1974	var l int
				1975	_ = l
				1976	if len(m.DryRun) > 0 {
				1977	for _, s := range m.DryRun {
				1978	dAtA[i] = 0xa
				1979	i++
				1980	l = len(s)
				1981	for l >= 1<<7 {
				1982	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				1983	l >>= 7
				1984	i++
				1985	}
				1986	dAtA[i] = uint8(l)
				1987	i++
				1988	i += copy(dAtA[i:], s)
				1989	}
				1990	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	1991	dAtA[i] = 0x12
				1992	i++
				1993	i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldManager)))
				1994	i += copy(dAtA[i:], m.FieldManager)
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	1995	return i, nil
				1996	}
				1997
				1998	func (m Verbs) Marshal() (dAtA []byte, err error) {
				1999	size := m.Size()
				2000	dAtA = make([]byte, size)
				2001	n, err := m.MarshalTo(dAtA)
				2002	if err != nil {
				2003	return nil, err
				2004	}
				2005	return dAtA[:n], nil
				2006	}
				2007
				2008	func (m Verbs) MarshalTo(dAtA []byte) (int, error) {
				2009	var i int
				2010	_ = i
				2011	var l int
				2012	_ = l
				2013	if len(m) > 0 {
				2014	for _, s := range m {
				2015	dAtA[i] = 0xa
				2016	i++
				2017	l = len(s)
				2018	for l >= 1<<7 {
				2019	dAtA[i] = uint8(uint64(l)&0x7f \| 0x80)
				2020	l >>= 7
				2021	i++
				2022	}
				2023	dAtA[i] = uint8(l)
				2024	i++
				2025	i += copy(dAtA[i:], s)
				2026	}
				2027	}
				2028	return i, nil
				2029	}
				2030
				2031	func (m *WatchEvent) Marshal() (dAtA []byte, err error) {
				2032	size := m.Size()
				2033	dAtA = make([]byte, size)
				2034	n, err := m.MarshalTo(dAtA)
				2035	if err != nil {
				2036	return nil, err
				2037	}
				2038	return dAtA[:n], nil
				2039	}
				2040
				2041	func (m *WatchEvent) MarshalTo(dAtA []byte) (int, error) {
				2042	var i int
				2043	_ = i
				2044	var l int
				2045	_ = l
				2046	dAtA[i] = 0xa
				2047	i++
				2048	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
				2049	i += copy(dAtA[i:], m.Type)
				2050	dAtA[i] = 0x12
				2051	i++
				2052	i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2053	n16, err := m.Object.MarshalTo(dAtA[i:])
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2054	if err != nil {
				2055	return 0, err
				2056	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2057	i += n16
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2058	return i, nil
				2059	}
				2060
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2061	func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
				2062	for v >= 1<<7 {
				2063	dAtA[offset] = uint8(v&0x7f \| 0x80)
				2064	v >>= 7
				2065	offset++
				2066	}
				2067	dAtA[offset] = uint8(v)
				2068	return offset + 1
				2069	}
				2070	func (m *APIGroup) Size() (n int) {
				2071	var l int
				2072	_ = l
				2073	l = len(m.Name)
				2074	n += 1 + l + sovGenerated(uint64(l))
				2075	if len(m.Versions) > 0 {
				2076	for _, e := range m.Versions {
				2077	l = e.Size()
				2078	n += 1 + l + sovGenerated(uint64(l))
				2079	}
				2080	}
				2081	l = m.PreferredVersion.Size()
				2082	n += 1 + l + sovGenerated(uint64(l))
				2083	if len(m.ServerAddressByClientCIDRs) > 0 {
				2084	for _, e := range m.ServerAddressByClientCIDRs {
				2085	l = e.Size()
				2086	n += 1 + l + sovGenerated(uint64(l))
				2087	}
				2088	}
				2089	return n
				2090	}
				2091
				2092	func (m *APIGroupList) Size() (n int) {
				2093	var l int
				2094	_ = l
				2095	if len(m.Groups) > 0 {
				2096	for _, e := range m.Groups {
				2097	l = e.Size()
				2098	n += 1 + l + sovGenerated(uint64(l))
				2099	}
				2100	}
				2101	return n
				2102	}
				2103
				2104	func (m *APIResource) Size() (n int) {
				2105	var l int
				2106	_ = l
				2107	l = len(m.Name)
				2108	n += 1 + l + sovGenerated(uint64(l))
				2109	n += 2
				2110	l = len(m.Kind)
				2111	n += 1 + l + sovGenerated(uint64(l))
				2112	if m.Verbs != nil {
				2113	l = m.Verbs.Size()
				2114	n += 1 + l + sovGenerated(uint64(l))
				2115	}
				2116	if len(m.ShortNames) > 0 {
				2117	for _, s := range m.ShortNames {
				2118	l = len(s)
				2119	n += 1 + l + sovGenerated(uint64(l))
				2120	}
				2121	}
				2122	l = len(m.SingularName)
				2123	n += 1 + l + sovGenerated(uint64(l))
				2124	if len(m.Categories) > 0 {
				2125	for _, s := range m.Categories {
				2126	l = len(s)
				2127	n += 1 + l + sovGenerated(uint64(l))
				2128	}
				2129	}
				2130	l = len(m.Group)
				2131	n += 1 + l + sovGenerated(uint64(l))
				2132	l = len(m.Version)
				2133	n += 1 + l + sovGenerated(uint64(l))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2134	l = len(m.StorageVersionHash)
				2135	n += 1 + l + sovGenerated(uint64(l))
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2136	return n
				2137	}
				2138
				2139	func (m *APIResourceList) Size() (n int) {
				2140	var l int
				2141	_ = l
				2142	l = len(m.GroupVersion)
				2143	n += 1 + l + sovGenerated(uint64(l))
				2144	if len(m.APIResources) > 0 {
				2145	for _, e := range m.APIResources {
				2146	l = e.Size()
				2147	n += 1 + l + sovGenerated(uint64(l))
				2148	}
				2149	}
				2150	return n
				2151	}
				2152
				2153	func (m *APIVersions) Size() (n int) {
				2154	var l int
				2155	_ = l
				2156	if len(m.Versions) > 0 {
				2157	for _, s := range m.Versions {
				2158	l = len(s)
				2159	n += 1 + l + sovGenerated(uint64(l))
				2160	}
				2161	}
				2162	if len(m.ServerAddressByClientCIDRs) > 0 {
				2163	for _, e := range m.ServerAddressByClientCIDRs {
				2164	l = e.Size()
				2165	n += 1 + l + sovGenerated(uint64(l))
				2166	}
				2167	}
				2168	return n
				2169	}
				2170
				2171	func (m *CreateOptions) Size() (n int) {
				2172	var l int
				2173	_ = l
				2174	if len(m.DryRun) > 0 {
				2175	for _, s := range m.DryRun {
				2176	l = len(s)
				2177	n += 1 + l + sovGenerated(uint64(l))
				2178	}
				2179	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2180	l = len(m.FieldManager)
				2181	n += 1 + l + sovGenerated(uint64(l))
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2182	return n
				2183	}
				2184
				2185	func (m *DeleteOptions) Size() (n int) {
				2186	var l int
				2187	_ = l
				2188	if m.GracePeriodSeconds != nil {
				2189	n += 1 + sovGenerated(uint64(*m.GracePeriodSeconds))
				2190	}
				2191	if m.Preconditions != nil {
				2192	l = m.Preconditions.Size()
				2193	n += 1 + l + sovGenerated(uint64(l))
				2194	}
				2195	if m.OrphanDependents != nil {
				2196	n += 2
				2197	}
				2198	if m.PropagationPolicy != nil {
				2199	l = len(*m.PropagationPolicy)
				2200	n += 1 + l + sovGenerated(uint64(l))
				2201	}
				2202	if len(m.DryRun) > 0 {
				2203	for _, s := range m.DryRun {
				2204	l = len(s)
				2205	n += 1 + l + sovGenerated(uint64(l))
				2206	}
				2207	}
				2208	return n
				2209	}
				2210
				2211	func (m *Duration) Size() (n int) {
				2212	var l int
				2213	_ = l
				2214	n += 1 + sovGenerated(uint64(m.Duration))
				2215	return n
				2216	}
				2217
				2218	func (m *ExportOptions) Size() (n int) {
				2219	var l int
				2220	_ = l
				2221	n += 2
				2222	n += 2
				2223	return n
				2224	}
				2225
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2226	func (m *Fields) Size() (n int) {
				2227	var l int
				2228	_ = l
				2229	if len(m.Map) > 0 {
				2230	for k, v := range m.Map {
				2231	_ = k
				2232	_ = v
				2233	l = v.Size()
				2234	mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
				2235	n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
				2236	}
				2237	}
				2238	return n
				2239	}
				2240
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2241	func (m *GetOptions) Size() (n int) {
				2242	var l int
				2243	_ = l
				2244	l = len(m.ResourceVersion)
				2245	n += 1 + l + sovGenerated(uint64(l))
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2246	return n
				2247	}
				2248
				2249	func (m *GroupKind) Size() (n int) {
				2250	var l int
				2251	_ = l
				2252	l = len(m.Group)
				2253	n += 1 + l + sovGenerated(uint64(l))
				2254	l = len(m.Kind)
				2255	n += 1 + l + sovGenerated(uint64(l))
				2256	return n
				2257	}
				2258
				2259	func (m *GroupResource) Size() (n int) {
				2260	var l int
				2261	_ = l
				2262	l = len(m.Group)
				2263	n += 1 + l + sovGenerated(uint64(l))
				2264	l = len(m.Resource)
				2265	n += 1 + l + sovGenerated(uint64(l))
				2266	return n
				2267	}
				2268
				2269	func (m *GroupVersion) Size() (n int) {
				2270	var l int
				2271	_ = l
				2272	l = len(m.Group)
				2273	n += 1 + l + sovGenerated(uint64(l))
				2274	l = len(m.Version)
				2275	n += 1 + l + sovGenerated(uint64(l))
				2276	return n
				2277	}
				2278
				2279	func (m *GroupVersionForDiscovery) Size() (n int) {
				2280	var l int
				2281	_ = l
				2282	l = len(m.GroupVersion)
				2283	n += 1 + l + sovGenerated(uint64(l))
				2284	l = len(m.Version)
				2285	n += 1 + l + sovGenerated(uint64(l))
				2286	return n
				2287	}
				2288
				2289	func (m *GroupVersionKind) Size() (n int) {
				2290	var l int
				2291	_ = l
				2292	l = len(m.Group)
				2293	n += 1 + l + sovGenerated(uint64(l))
				2294	l = len(m.Version)
				2295	n += 1 + l + sovGenerated(uint64(l))
				2296	l = len(m.Kind)
				2297	n += 1 + l + sovGenerated(uint64(l))
				2298	return n
				2299	}
				2300
				2301	func (m *GroupVersionResource) Size() (n int) {
				2302	var l int
				2303	_ = l
				2304	l = len(m.Group)
				2305	n += 1 + l + sovGenerated(uint64(l))
				2306	l = len(m.Version)
				2307	n += 1 + l + sovGenerated(uint64(l))
				2308	l = len(m.Resource)
				2309	n += 1 + l + sovGenerated(uint64(l))
				2310	return n
				2311	}
				2312
				2313	func (m *Initializer) Size() (n int) {
				2314	var l int
				2315	_ = l
				2316	l = len(m.Name)
				2317	n += 1 + l + sovGenerated(uint64(l))
				2318	return n
				2319	}
				2320
				2321	func (m *Initializers) Size() (n int) {
				2322	var l int
				2323	_ = l
				2324	if len(m.Pending) > 0 {
				2325	for _, e := range m.Pending {
				2326	l = e.Size()
				2327	n += 1 + l + sovGenerated(uint64(l))
				2328	}
				2329	}
				2330	if m.Result != nil {
				2331	l = m.Result.Size()
				2332	n += 1 + l + sovGenerated(uint64(l))
				2333	}
				2334	return n
				2335	}
				2336
				2337	func (m *LabelSelector) Size() (n int) {
				2338	var l int
				2339	_ = l
				2340	if len(m.MatchLabels) > 0 {
				2341	for k, v := range m.MatchLabels {
				2342	_ = k
				2343	_ = v
				2344	mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				2345	n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
				2346	}
				2347	}
				2348	if len(m.MatchExpressions) > 0 {
				2349	for _, e := range m.MatchExpressions {
				2350	l = e.Size()
				2351	n += 1 + l + sovGenerated(uint64(l))
				2352	}
				2353	}
				2354	return n
				2355	}
				2356
				2357	func (m *LabelSelectorRequirement) Size() (n int) {
				2358	var l int
				2359	_ = l
				2360	l = len(m.Key)
				2361	n += 1 + l + sovGenerated(uint64(l))
				2362	l = len(m.Operator)
				2363	n += 1 + l + sovGenerated(uint64(l))
				2364	if len(m.Values) > 0 {
				2365	for _, s := range m.Values {
				2366	l = len(s)
				2367	n += 1 + l + sovGenerated(uint64(l))
				2368	}
				2369	}
				2370	return n
				2371	}
				2372
				2373	func (m *List) Size() (n int) {
				2374	var l int
				2375	_ = l
				2376	l = m.ListMeta.Size()
				2377	n += 1 + l + sovGenerated(uint64(l))
				2378	if len(m.Items) > 0 {
				2379	for _, e := range m.Items {
				2380	l = e.Size()
				2381	n += 1 + l + sovGenerated(uint64(l))
				2382	}
				2383	}
				2384	return n
				2385	}
				2386
				2387	func (m *ListMeta) Size() (n int) {
				2388	var l int
				2389	_ = l
				2390	l = len(m.SelfLink)
				2391	n += 1 + l + sovGenerated(uint64(l))
				2392	l = len(m.ResourceVersion)
				2393	n += 1 + l + sovGenerated(uint64(l))
				2394	l = len(m.Continue)
				2395	n += 1 + l + sovGenerated(uint64(l))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2396	if m.RemainingItemCount != nil {
				2397	n += 1 + sovGenerated(uint64(*m.RemainingItemCount))
				2398	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2399	return n
				2400	}
				2401
				2402	func (m *ListOptions) Size() (n int) {
				2403	var l int
				2404	_ = l
				2405	l = len(m.LabelSelector)
				2406	n += 1 + l + sovGenerated(uint64(l))
				2407	l = len(m.FieldSelector)
				2408	n += 1 + l + sovGenerated(uint64(l))
				2409	n += 2
				2410	l = len(m.ResourceVersion)
				2411	n += 1 + l + sovGenerated(uint64(l))
				2412	if m.TimeoutSeconds != nil {
				2413	n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
				2414	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2415	n += 1 + sovGenerated(uint64(m.Limit))
				2416	l = len(m.Continue)
				2417	n += 1 + l + sovGenerated(uint64(l))
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2418	n += 2
				2419	return n
				2420	}
				2421
				2422	func (m *ManagedFieldsEntry) Size() (n int) {
				2423	var l int
				2424	_ = l
				2425	l = len(m.Manager)
				2426	n += 1 + l + sovGenerated(uint64(l))
				2427	l = len(m.Operation)
				2428	n += 1 + l + sovGenerated(uint64(l))
				2429	l = len(m.APIVersion)
				2430	n += 1 + l + sovGenerated(uint64(l))
				2431	if m.Time != nil {
				2432	l = m.Time.Size()
				2433	n += 1 + l + sovGenerated(uint64(l))
				2434	}
				2435	if m.Fields != nil {
				2436	l = m.Fields.Size()
				2437	n += 1 + l + sovGenerated(uint64(l))
				2438	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2439	return n
				2440	}
				2441
				2442	func (m *ObjectMeta) Size() (n int) {
				2443	var l int
				2444	_ = l
				2445	l = len(m.Name)
				2446	n += 1 + l + sovGenerated(uint64(l))
				2447	l = len(m.GenerateName)
				2448	n += 1 + l + sovGenerated(uint64(l))
				2449	l = len(m.Namespace)
				2450	n += 1 + l + sovGenerated(uint64(l))
				2451	l = len(m.SelfLink)
				2452	n += 1 + l + sovGenerated(uint64(l))
				2453	l = len(m.UID)
				2454	n += 1 + l + sovGenerated(uint64(l))
				2455	l = len(m.ResourceVersion)
				2456	n += 1 + l + sovGenerated(uint64(l))
				2457	n += 1 + sovGenerated(uint64(m.Generation))
				2458	l = m.CreationTimestamp.Size()
				2459	n += 1 + l + sovGenerated(uint64(l))
				2460	if m.DeletionTimestamp != nil {
				2461	l = m.DeletionTimestamp.Size()
				2462	n += 1 + l + sovGenerated(uint64(l))
				2463	}
				2464	if m.DeletionGracePeriodSeconds != nil {
				2465	n += 1 + sovGenerated(uint64(*m.DeletionGracePeriodSeconds))
				2466	}
				2467	if len(m.Labels) > 0 {
				2468	for k, v := range m.Labels {
				2469	_ = k
				2470	_ = v
				2471	mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				2472	n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
				2473	}
				2474	}
				2475	if len(m.Annotations) > 0 {
				2476	for k, v := range m.Annotations {
				2477	_ = k
				2478	_ = v
				2479	mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
				2480	n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
				2481	}
				2482	}
				2483	if len(m.OwnerReferences) > 0 {
				2484	for _, e := range m.OwnerReferences {
				2485	l = e.Size()
				2486	n += 1 + l + sovGenerated(uint64(l))
				2487	}
				2488	}
				2489	if len(m.Finalizers) > 0 {
				2490	for _, s := range m.Finalizers {
				2491	l = len(s)
				2492	n += 1 + l + sovGenerated(uint64(l))
				2493	}
				2494	}
				2495	l = len(m.ClusterName)
				2496	n += 1 + l + sovGenerated(uint64(l))
				2497	if m.Initializers != nil {
				2498	l = m.Initializers.Size()
				2499	n += 2 + l + sovGenerated(uint64(l))
				2500	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2501	if len(m.ManagedFields) > 0 {
				2502	for _, e := range m.ManagedFields {
				2503	l = e.Size()
				2504	n += 2 + l + sovGenerated(uint64(l))
				2505	}
				2506	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2507	return n
				2508	}
				2509
				2510	func (m *OwnerReference) Size() (n int) {
				2511	var l int
				2512	_ = l
				2513	l = len(m.Kind)
				2514	n += 1 + l + sovGenerated(uint64(l))
				2515	l = len(m.Name)
				2516	n += 1 + l + sovGenerated(uint64(l))
				2517	l = len(m.UID)
				2518	n += 1 + l + sovGenerated(uint64(l))
				2519	l = len(m.APIVersion)
				2520	n += 1 + l + sovGenerated(uint64(l))
				2521	if m.Controller != nil {
				2522	n += 2
				2523	}
				2524	if m.BlockOwnerDeletion != nil {
				2525	n += 2
				2526	}
				2527	return n
				2528	}
				2529
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2530	func (m *PartialObjectMetadata) Size() (n int) {
				2531	var l int
				2532	_ = l
				2533	l = m.ObjectMeta.Size()
				2534	n += 1 + l + sovGenerated(uint64(l))
				2535	return n
				2536	}
				2537
				2538	func (m *PartialObjectMetadataList) Size() (n int) {
				2539	var l int
				2540	_ = l
				2541	l = m.ListMeta.Size()
				2542	n += 1 + l + sovGenerated(uint64(l))
				2543	if len(m.Items) > 0 {
				2544	for _, e := range m.Items {
				2545	l = e.Size()
				2546	n += 1 + l + sovGenerated(uint64(l))
				2547	}
				2548	}
				2549	return n
				2550	}
				2551
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2552	func (m *Patch) Size() (n int) {
				2553	var l int
				2554	_ = l
				2555	return n
				2556	}
				2557
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2558	func (m *PatchOptions) Size() (n int) {
				2559	var l int
				2560	_ = l
				2561	if len(m.DryRun) > 0 {
				2562	for _, s := range m.DryRun {
				2563	l = len(s)
				2564	n += 1 + l + sovGenerated(uint64(l))
				2565	}
				2566	}
				2567	if m.Force != nil {
				2568	n += 2
				2569	}
				2570	l = len(m.FieldManager)
				2571	n += 1 + l + sovGenerated(uint64(l))
				2572	return n
				2573	}
				2574
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2575	func (m *Preconditions) Size() (n int) {
				2576	var l int
				2577	_ = l
				2578	if m.UID != nil {
				2579	l = len(*m.UID)
				2580	n += 1 + l + sovGenerated(uint64(l))
				2581	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2582	if m.ResourceVersion != nil {
				2583	l = len(*m.ResourceVersion)
				2584	n += 1 + l + sovGenerated(uint64(l))
				2585	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2586	return n
				2587	}
				2588
				2589	func (m *RootPaths) Size() (n int) {
				2590	var l int
				2591	_ = l
				2592	if len(m.Paths) > 0 {
				2593	for _, s := range m.Paths {
				2594	l = len(s)
				2595	n += 1 + l + sovGenerated(uint64(l))
				2596	}
				2597	}
				2598	return n
				2599	}
				2600
				2601	func (m *ServerAddressByClientCIDR) Size() (n int) {
				2602	var l int
				2603	_ = l
				2604	l = len(m.ClientCIDR)
				2605	n += 1 + l + sovGenerated(uint64(l))
				2606	l = len(m.ServerAddress)
				2607	n += 1 + l + sovGenerated(uint64(l))
				2608	return n
				2609	}
				2610
				2611	func (m *Status) Size() (n int) {
				2612	var l int
				2613	_ = l
				2614	l = m.ListMeta.Size()
				2615	n += 1 + l + sovGenerated(uint64(l))
				2616	l = len(m.Status)
				2617	n += 1 + l + sovGenerated(uint64(l))
				2618	l = len(m.Message)
				2619	n += 1 + l + sovGenerated(uint64(l))
				2620	l = len(m.Reason)
				2621	n += 1 + l + sovGenerated(uint64(l))
				2622	if m.Details != nil {
				2623	l = m.Details.Size()
				2624	n += 1 + l + sovGenerated(uint64(l))
				2625	}
				2626	n += 1 + sovGenerated(uint64(m.Code))
				2627	return n
				2628	}
				2629
				2630	func (m *StatusCause) Size() (n int) {
				2631	var l int
				2632	_ = l
				2633	l = len(m.Type)
				2634	n += 1 + l + sovGenerated(uint64(l))
				2635	l = len(m.Message)
				2636	n += 1 + l + sovGenerated(uint64(l))
				2637	l = len(m.Field)
				2638	n += 1 + l + sovGenerated(uint64(l))
				2639	return n
				2640	}
				2641
				2642	func (m *StatusDetails) Size() (n int) {
				2643	var l int
				2644	_ = l
				2645	l = len(m.Name)
				2646	n += 1 + l + sovGenerated(uint64(l))
				2647	l = len(m.Group)
				2648	n += 1 + l + sovGenerated(uint64(l))
				2649	l = len(m.Kind)
				2650	n += 1 + l + sovGenerated(uint64(l))
				2651	if len(m.Causes) > 0 {
				2652	for _, e := range m.Causes {
				2653	l = e.Size()
				2654	n += 1 + l + sovGenerated(uint64(l))
				2655	}
				2656	}
				2657	n += 1 + sovGenerated(uint64(m.RetryAfterSeconds))
				2658	l = len(m.UID)
				2659	n += 1 + l + sovGenerated(uint64(l))
				2660	return n
				2661	}
				2662
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2663	func (m *TableOptions) Size() (n int) {
				2664	var l int
				2665	_ = l
				2666	l = len(m.IncludeObject)
				2667	n += 1 + l + sovGenerated(uint64(l))
				2668	return n
				2669	}
				2670
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2671	func (m *Timestamp) Size() (n int) {
				2672	var l int
				2673	_ = l
				2674	n += 1 + sovGenerated(uint64(m.Seconds))
				2675	n += 1 + sovGenerated(uint64(m.Nanos))
				2676	return n
				2677	}
				2678
				2679	func (m *TypeMeta) Size() (n int) {
				2680	var l int
				2681	_ = l
				2682	l = len(m.Kind)
				2683	n += 1 + l + sovGenerated(uint64(l))
				2684	l = len(m.APIVersion)
				2685	n += 1 + l + sovGenerated(uint64(l))
				2686	return n
				2687	}
				2688
				2689	func (m *UpdateOptions) Size() (n int) {
				2690	var l int
				2691	_ = l
				2692	if len(m.DryRun) > 0 {
				2693	for _, s := range m.DryRun {
				2694	l = len(s)
				2695	n += 1 + l + sovGenerated(uint64(l))
				2696	}
				2697	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2698	l = len(m.FieldManager)
				2699	n += 1 + l + sovGenerated(uint64(l))
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2700	return n
				2701	}
				2702
				2703	func (m Verbs) Size() (n int) {
				2704	var l int
				2705	_ = l
				2706	if len(m) > 0 {
				2707	for _, s := range m {
				2708	l = len(s)
				2709	n += 1 + l + sovGenerated(uint64(l))
				2710	}
				2711	}
				2712	return n
				2713	}
				2714
				2715	func (m *WatchEvent) Size() (n int) {
				2716	var l int
				2717	_ = l
				2718	l = len(m.Type)
				2719	n += 1 + l + sovGenerated(uint64(l))
				2720	l = m.Object.Size()
				2721	n += 1 + l + sovGenerated(uint64(l))
				2722	return n
				2723	}
				2724
				2725	func sovGenerated(x uint64) (n int) {
				2726	for {
				2727	n++
				2728	x >>= 7
				2729	if x == 0 {
				2730	break
				2731	}
				2732	}
				2733	return n
				2734	}
				2735	func sozGenerated(x uint64) (n int) {
				2736	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
				2737	}
				2738	func (this *APIGroup) String() string {
				2739	if this == nil {
				2740	return "nil"
				2741	}
				2742	s := strings.Join([]string{`&APIGroup{`,
				2743	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				2744	`Versions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Versions), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
				2745	`PreferredVersion:` + strings.Replace(strings.Replace(this.PreferredVersion.String(), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
				2746	`ServerAddressByClientCIDRs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServerAddressByClientCIDRs), "ServerAddressByClientCIDR", "ServerAddressByClientCIDR", 1), `&`, ``, 1) + `,`,
				2747	`}`,
				2748	}, "")
				2749	return s
				2750	}
				2751	func (this *APIGroupList) String() string {
				2752	if this == nil {
				2753	return "nil"
				2754	}
				2755	s := strings.Join([]string{`&APIGroupList{`,
				2756	`Groups:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Groups), "APIGroup", "APIGroup", 1), `&`, ``, 1) + `,`,
				2757	`}`,
				2758	}, "")
				2759	return s
				2760	}
				2761	func (this *APIResource) String() string {
				2762	if this == nil {
				2763	return "nil"
				2764	}
				2765	s := strings.Join([]string{`&APIResource{`,
				2766	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				2767	`Namespaced:` + fmt.Sprintf("%v", this.Namespaced) + `,`,
				2768	`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
				2769	`Verbs:` + strings.Replace(fmt.Sprintf("%v", this.Verbs), "Verbs", "Verbs", 1) + `,`,
				2770	`ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`,
				2771	`SingularName:` + fmt.Sprintf("%v", this.SingularName) + `,`,
				2772	`Categories:` + fmt.Sprintf("%v", this.Categories) + `,`,
				2773	`Group:` + fmt.Sprintf("%v", this.Group) + `,`,
				2774	`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2775	`StorageVersionHash:` + fmt.Sprintf("%v", this.StorageVersionHash) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2776	`}`,
				2777	}, "")
				2778	return s
				2779	}
				2780	func (this *APIResourceList) String() string {
				2781	if this == nil {
				2782	return "nil"
				2783	}
				2784	s := strings.Join([]string{`&APIResourceList{`,
				2785	`GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
				2786	`APIResources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.APIResources), "APIResource", "APIResource", 1), `&`, ``, 1) + `,`,
				2787	`}`,
				2788	}, "")
				2789	return s
				2790	}
				2791	func (this *CreateOptions) String() string {
				2792	if this == nil {
				2793	return "nil"
				2794	}
				2795	s := strings.Join([]string{`&CreateOptions{`,
				2796	`DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2797	`FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2798	`}`,
				2799	}, "")
				2800	return s
				2801	}
				2802	func (this *DeleteOptions) String() string {
				2803	if this == nil {
				2804	return "nil"
				2805	}
				2806	s := strings.Join([]string{`&DeleteOptions{`,
				2807	`GracePeriodSeconds:` + valueToStringGenerated(this.GracePeriodSeconds) + `,`,
				2808	`Preconditions:` + strings.Replace(fmt.Sprintf("%v", this.Preconditions), "Preconditions", "Preconditions", 1) + `,`,
				2809	`OrphanDependents:` + valueToStringGenerated(this.OrphanDependents) + `,`,
				2810	`PropagationPolicy:` + valueToStringGenerated(this.PropagationPolicy) + `,`,
				2811	`DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
				2812	`}`,
				2813	}, "")
				2814	return s
				2815	}
				2816	func (this *Duration) String() string {
				2817	if this == nil {
				2818	return "nil"
				2819	}
				2820	s := strings.Join([]string{`&Duration{`,
				2821	`Duration:` + fmt.Sprintf("%v", this.Duration) + `,`,
				2822	`}`,
				2823	}, "")
				2824	return s
				2825	}
				2826	func (this *ExportOptions) String() string {
				2827	if this == nil {
				2828	return "nil"
				2829	}
				2830	s := strings.Join([]string{`&ExportOptions{`,
				2831	`Export:` + fmt.Sprintf("%v", this.Export) + `,`,
				2832	`Exact:` + fmt.Sprintf("%v", this.Exact) + `,`,
				2833	`}`,
				2834	}, "")
				2835	return s
				2836	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2837	func (this *Fields) String() string {
				2838	if this == nil {
				2839	return "nil"
				2840	}
				2841	keysForMap := make([]string, 0, len(this.Map))
				2842	for k := range this.Map {
				2843	keysForMap = append(keysForMap, k)
				2844	}
				2845	github_com_gogo_protobuf_sortkeys.Strings(keysForMap)
				2846	mapStringForMap := "map[string]Fields{"
				2847	for _, k := range keysForMap {
				2848	mapStringForMap += fmt.Sprintf("%v: %v,", k, this.Map[k])
				2849	}
				2850	mapStringForMap += "}"
				2851	s := strings.Join([]string{`&Fields{`,
				2852	`Map:` + mapStringForMap + `,`,
				2853	`}`,
				2854	}, "")
				2855	return s
				2856	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2857	func (this *GetOptions) String() string {
				2858	if this == nil {
				2859	return "nil"
				2860	}
				2861	s := strings.Join([]string{`&GetOptions{`,
				2862	`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2863	`}`,
				2864	}, "")
				2865	return s
				2866	}
				2867	func (this *GroupVersionForDiscovery) String() string {
				2868	if this == nil {
				2869	return "nil"
				2870	}
				2871	s := strings.Join([]string{`&GroupVersionForDiscovery{`,
				2872	`GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
				2873	`Version:` + fmt.Sprintf("%v", this.Version) + `,`,
				2874	`}`,
				2875	}, "")
				2876	return s
				2877	}
				2878	func (this *Initializer) String() string {
				2879	if this == nil {
				2880	return "nil"
				2881	}
				2882	s := strings.Join([]string{`&Initializer{`,
				2883	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				2884	`}`,
				2885	}, "")
				2886	return s
				2887	}
				2888	func (this *Initializers) String() string {
				2889	if this == nil {
				2890	return "nil"
				2891	}
				2892	s := strings.Join([]string{`&Initializers{`,
				2893	`Pending:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Pending), "Initializer", "Initializer", 1), `&`, ``, 1) + `,`,
				2894	`Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "Status", 1) + `,`,
				2895	`}`,
				2896	}, "")
				2897	return s
				2898	}
				2899	func (this *LabelSelector) String() string {
				2900	if this == nil {
				2901	return "nil"
				2902	}
				2903	keysForMatchLabels := make([]string, 0, len(this.MatchLabels))
				2904	for k := range this.MatchLabels {
				2905	keysForMatchLabels = append(keysForMatchLabels, k)
				2906	}
				2907	github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
				2908	mapStringForMatchLabels := "map[string]string{"
				2909	for _, k := range keysForMatchLabels {
				2910	mapStringForMatchLabels += fmt.Sprintf("%v: %v,", k, this.MatchLabels[k])
				2911	}
				2912	mapStringForMatchLabels += "}"
				2913	s := strings.Join([]string{`&LabelSelector{`,
				2914	`MatchLabels:` + mapStringForMatchLabels + `,`,
				2915	`MatchExpressions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MatchExpressions), "LabelSelectorRequirement", "LabelSelectorRequirement", 1), `&`, ``, 1) + `,`,
				2916	`}`,
				2917	}, "")
				2918	return s
				2919	}
				2920	func (this *LabelSelectorRequirement) String() string {
				2921	if this == nil {
				2922	return "nil"
				2923	}
				2924	s := strings.Join([]string{`&LabelSelectorRequirement{`,
				2925	`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
				2926	`Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
				2927	`Values:` + fmt.Sprintf("%v", this.Values) + `,`,
				2928	`}`,
				2929	}, "")
				2930	return s
				2931	}
				2932	func (this *List) String() string {
				2933	if this == nil {
				2934	return "nil"
				2935	}
				2936	s := strings.Join([]string{`&List{`,
				2937	`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
				2938	`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
				2939	`}`,
				2940	}, "")
				2941	return s
				2942	}
				2943	func (this *ListMeta) String() string {
				2944	if this == nil {
				2945	return "nil"
				2946	}
				2947	s := strings.Join([]string{`&ListMeta{`,
				2948	`SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
				2949	`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
				2950	`Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2951	`RemainingItemCount:` + valueToStringGenerated(this.RemainingItemCount) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2952	`}`,
				2953	}, "")
				2954	return s
				2955	}
				2956	func (this *ListOptions) String() string {
				2957	if this == nil {
				2958	return "nil"
				2959	}
				2960	s := strings.Join([]string{`&ListOptions{`,
				2961	`LabelSelector:` + fmt.Sprintf("%v", this.LabelSelector) + `,`,
				2962	`FieldSelector:` + fmt.Sprintf("%v", this.FieldSelector) + `,`,
				2963	`Watch:` + fmt.Sprintf("%v", this.Watch) + `,`,
				2964	`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
				2965	`TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2966	`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
				2967	`Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	2968	`AllowWatchBookmarks:` + fmt.Sprintf("%v", this.AllowWatchBookmarks) + `,`,
				2969	`}`,
				2970	}, "")
				2971	return s
				2972	}
				2973	func (this *ManagedFieldsEntry) String() string {
				2974	if this == nil {
				2975	return "nil"
				2976	}
				2977	s := strings.Join([]string{`&ManagedFieldsEntry{`,
				2978	`Manager:` + fmt.Sprintf("%v", this.Manager) + `,`,
				2979	`Operation:` + fmt.Sprintf("%v", this.Operation) + `,`,
				2980	`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
				2981	`Time:` + strings.Replace(fmt.Sprintf("%v", this.Time), "Time", "Time", 1) + `,`,
				2982	`Fields:` + strings.Replace(fmt.Sprintf("%v", this.Fields), "Fields", "Fields", 1) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	2983	`}`,
				2984	}, "")
				2985	return s
				2986	}
				2987	func (this *ObjectMeta) String() string {
				2988	if this == nil {
				2989	return "nil"
				2990	}
				2991	keysForLabels := make([]string, 0, len(this.Labels))
				2992	for k := range this.Labels {
				2993	keysForLabels = append(keysForLabels, k)
				2994	}
				2995	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
				2996	mapStringForLabels := "map[string]string{"
				2997	for _, k := range keysForLabels {
				2998	mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
				2999	}
				3000	mapStringForLabels += "}"
				3001	keysForAnnotations := make([]string, 0, len(this.Annotations))
				3002	for k := range this.Annotations {
				3003	keysForAnnotations = append(keysForAnnotations, k)
				3004	}
				3005	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
				3006	mapStringForAnnotations := "map[string]string{"
				3007	for _, k := range keysForAnnotations {
				3008	mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
				3009	}
				3010	mapStringForAnnotations += "}"
				3011	s := strings.Join([]string{`&ObjectMeta{`,
				3012	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				3013	`GenerateName:` + fmt.Sprintf("%v", this.GenerateName) + `,`,
				3014	`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
				3015	`SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
				3016	`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
				3017	`ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
				3018	`Generation:` + fmt.Sprintf("%v", this.Generation) + `,`,
				3019	`CreationTimestamp:` + strings.Replace(strings.Replace(this.CreationTimestamp.String(), "Time", "Time", 1), `&`, ``, 1) + `,`,
				3020	`DeletionTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DeletionTimestamp), "Time", "Time", 1) + `,`,
				3021	`DeletionGracePeriodSeconds:` + valueToStringGenerated(this.DeletionGracePeriodSeconds) + `,`,
				3022	`Labels:` + mapStringForLabels + `,`,
				3023	`Annotations:` + mapStringForAnnotations + `,`,
				3024	`OwnerReferences:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OwnerReferences), "OwnerReference", "OwnerReference", 1), `&`, ``, 1) + `,`,
				3025	`Finalizers:` + fmt.Sprintf("%v", this.Finalizers) + `,`,
				3026	`ClusterName:` + fmt.Sprintf("%v", this.ClusterName) + `,`,
				3027	`Initializers:` + strings.Replace(fmt.Sprintf("%v", this.Initializers), "Initializers", "Initializers", 1) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3028	`ManagedFields:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ManagedFields), "ManagedFieldsEntry", "ManagedFieldsEntry", 1), `&`, ``, 1) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3029	`}`,
				3030	}, "")
				3031	return s
				3032	}
				3033	func (this *OwnerReference) String() string {
				3034	if this == nil {
				3035	return "nil"
				3036	}
				3037	s := strings.Join([]string{`&OwnerReference{`,
				3038	`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
				3039	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				3040	`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
				3041	`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
				3042	`Controller:` + valueToStringGenerated(this.Controller) + `,`,
				3043	`BlockOwnerDeletion:` + valueToStringGenerated(this.BlockOwnerDeletion) + `,`,
				3044	`}`,
				3045	}, "")
				3046	return s
				3047	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3048	func (this *PartialObjectMetadata) String() string {
				3049	if this == nil {
				3050	return "nil"
				3051	}
				3052	s := strings.Join([]string{`&PartialObjectMetadata{`,
				3053	`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "ObjectMeta", 1), `&`, ``, 1) + `,`,
				3054	`}`,
				3055	}, "")
				3056	return s
				3057	}
				3058	func (this *PartialObjectMetadataList) String() string {
				3059	if this == nil {
				3060	return "nil"
				3061	}
				3062	s := strings.Join([]string{`&PartialObjectMetadataList{`,
				3063	`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
				3064	`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PartialObjectMetadata", "PartialObjectMetadata", 1), `&`, ``, 1) + `,`,
				3065	`}`,
				3066	}, "")
				3067	return s
				3068	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3069	func (this *Patch) String() string {
				3070	if this == nil {
				3071	return "nil"
				3072	}
				3073	s := strings.Join([]string{`&Patch{`,
				3074	`}`,
				3075	}, "")
				3076	return s
				3077	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3078	func (this *PatchOptions) String() string {
				3079	if this == nil {
				3080	return "nil"
				3081	}
				3082	s := strings.Join([]string{`&PatchOptions{`,
				3083	`DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
				3084	`Force:` + valueToStringGenerated(this.Force) + `,`,
				3085	`FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`,
				3086	`}`,
				3087	}, "")
				3088	return s
				3089	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3090	func (this *Preconditions) String() string {
				3091	if this == nil {
				3092	return "nil"
				3093	}
				3094	s := strings.Join([]string{`&Preconditions{`,
				3095	`UID:` + valueToStringGenerated(this.UID) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3096	`ResourceVersion:` + valueToStringGenerated(this.ResourceVersion) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3097	`}`,
				3098	}, "")
				3099	return s
				3100	}
				3101	func (this *RootPaths) String() string {
				3102	if this == nil {
				3103	return "nil"
				3104	}
				3105	s := strings.Join([]string{`&RootPaths{`,
				3106	`Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
				3107	`}`,
				3108	}, "")
				3109	return s
				3110	}
				3111	func (this *ServerAddressByClientCIDR) String() string {
				3112	if this == nil {
				3113	return "nil"
				3114	}
				3115	s := strings.Join([]string{`&ServerAddressByClientCIDR{`,
				3116	`ClientCIDR:` + fmt.Sprintf("%v", this.ClientCIDR) + `,`,
				3117	`ServerAddress:` + fmt.Sprintf("%v", this.ServerAddress) + `,`,
				3118	`}`,
				3119	}, "")
				3120	return s
				3121	}
				3122	func (this *Status) String() string {
				3123	if this == nil {
				3124	return "nil"
				3125	}
				3126	s := strings.Join([]string{`&Status{`,
				3127	`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
				3128	`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
				3129	`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
				3130	`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
				3131	`Details:` + strings.Replace(fmt.Sprintf("%v", this.Details), "StatusDetails", "StatusDetails", 1) + `,`,
				3132	`Code:` + fmt.Sprintf("%v", this.Code) + `,`,
				3133	`}`,
				3134	}, "")
				3135	return s
				3136	}
				3137	func (this *StatusCause) String() string {
				3138	if this == nil {
				3139	return "nil"
				3140	}
				3141	s := strings.Join([]string{`&StatusCause{`,
				3142	`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
				3143	`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
				3144	`Field:` + fmt.Sprintf("%v", this.Field) + `,`,
				3145	`}`,
				3146	}, "")
				3147	return s
				3148	}
				3149	func (this *StatusDetails) String() string {
				3150	if this == nil {
				3151	return "nil"
				3152	}
				3153	s := strings.Join([]string{`&StatusDetails{`,
				3154	`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
				3155	`Group:` + fmt.Sprintf("%v", this.Group) + `,`,
				3156	`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
				3157	`Causes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Causes), "StatusCause", "StatusCause", 1), `&`, ``, 1) + `,`,
				3158	`RetryAfterSeconds:` + fmt.Sprintf("%v", this.RetryAfterSeconds) + `,`,
				3159	`UID:` + fmt.Sprintf("%v", this.UID) + `,`,
				3160	`}`,
				3161	}, "")
				3162	return s
				3163	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3164	func (this *TableOptions) String() string {
				3165	if this == nil {
				3166	return "nil"
				3167	}
				3168	s := strings.Join([]string{`&TableOptions{`,
				3169	`IncludeObject:` + fmt.Sprintf("%v", this.IncludeObject) + `,`,
				3170	`}`,
				3171	}, "")
				3172	return s
				3173	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3174	func (this *Timestamp) String() string {
				3175	if this == nil {
				3176	return "nil"
				3177	}
				3178	s := strings.Join([]string{`&Timestamp{`,
				3179	`Seconds:` + fmt.Sprintf("%v", this.Seconds) + `,`,
				3180	`Nanos:` + fmt.Sprintf("%v", this.Nanos) + `,`,
				3181	`}`,
				3182	}, "")
				3183	return s
				3184	}
				3185	func (this *TypeMeta) String() string {
				3186	if this == nil {
				3187	return "nil"
				3188	}
				3189	s := strings.Join([]string{`&TypeMeta{`,
				3190	`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
				3191	`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
				3192	`}`,
				3193	}, "")
				3194	return s
				3195	}
				3196	func (this *UpdateOptions) String() string {
				3197	if this == nil {
				3198	return "nil"
				3199	}
				3200	s := strings.Join([]string{`&UpdateOptions{`,
				3201	`DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3202	`FieldManager:` + fmt.Sprintf("%v", this.FieldManager) + `,`,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3203	`}`,
				3204	}, "")
				3205	return s
				3206	}
				3207	func (this *WatchEvent) String() string {
				3208	if this == nil {
				3209	return "nil"
				3210	}
				3211	s := strings.Join([]string{`&WatchEvent{`,
				3212	`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
				3213	`Object:` + strings.Replace(strings.Replace(this.Object.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
				3214	`}`,
				3215	}, "")
				3216	return s
				3217	}
				3218	func valueToStringGenerated(v interface{}) string {
				3219	rv := reflect.ValueOf(v)
				3220	if rv.IsNil() {
				3221	return "nil"
				3222	}
				3223	pv := reflect.Indirect(rv).Interface()
				3224	return fmt.Sprintf("*%v", pv)
				3225	}
				3226	func (m *APIGroup) Unmarshal(dAtA []byte) error {
				3227	l := len(dAtA)
				3228	iNdEx := 0
				3229	for iNdEx < l {
				3230	preIndex := iNdEx
				3231	var wire uint64
				3232	for shift := uint(0); ; shift += 7 {
				3233	if shift >= 64 {
				3234	return ErrIntOverflowGenerated
				3235	}
				3236	if iNdEx >= l {
				3237	return io.ErrUnexpectedEOF
				3238	}
				3239	b := dAtA[iNdEx]
				3240	iNdEx++
				3241	wire \|= (uint64(b) & 0x7F) << shift
				3242	if b < 0x80 {
				3243	break
				3244	}
				3245	}
				3246	fieldNum := int32(wire >> 3)
				3247	wireType := int(wire & 0x7)
				3248	if wireType == 4 {
				3249	return fmt.Errorf("proto: APIGroup: wiretype end group for non-group")
				3250	}
				3251	if fieldNum <= 0 {
				3252	return fmt.Errorf("proto: APIGroup: illegal tag %d (wire type %d)", fieldNum, wire)
				3253	}
				3254	switch fieldNum {
				3255	case 1:
				3256	if wireType != 2 {
				3257	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				3258	}
				3259	var stringLen uint64
				3260	for shift := uint(0); ; shift += 7 {
				3261	if shift >= 64 {
				3262	return ErrIntOverflowGenerated
				3263	}
				3264	if iNdEx >= l {
				3265	return io.ErrUnexpectedEOF
				3266	}
				3267	b := dAtA[iNdEx]
				3268	iNdEx++
				3269	stringLen \|= (uint64(b) & 0x7F) << shift
				3270	if b < 0x80 {
				3271	break
				3272	}
				3273	}
				3274	intStringLen := int(stringLen)
				3275	if intStringLen < 0 {
				3276	return ErrInvalidLengthGenerated
				3277	}
				3278	postIndex := iNdEx + intStringLen
				3279	if postIndex > l {
				3280	return io.ErrUnexpectedEOF
				3281	}
				3282	m.Name = string(dAtA[iNdEx:postIndex])
				3283	iNdEx = postIndex
				3284	case 2:
				3285	if wireType != 2 {
				3286	return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
				3287	}
				3288	var msglen int
				3289	for shift := uint(0); ; shift += 7 {
				3290	if shift >= 64 {
				3291	return ErrIntOverflowGenerated
				3292	}
				3293	if iNdEx >= l {
				3294	return io.ErrUnexpectedEOF
				3295	}
				3296	b := dAtA[iNdEx]
				3297	iNdEx++
				3298	msglen \|= (int(b) & 0x7F) << shift
				3299	if b < 0x80 {
				3300	break
				3301	}
				3302	}
				3303	if msglen < 0 {
				3304	return ErrInvalidLengthGenerated
				3305	}
				3306	postIndex := iNdEx + msglen
				3307	if postIndex > l {
				3308	return io.ErrUnexpectedEOF
				3309	}
				3310	m.Versions = append(m.Versions, GroupVersionForDiscovery{})
				3311	if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3312	return err
				3313	}
				3314	iNdEx = postIndex
				3315	case 3:
				3316	if wireType != 2 {
				3317	return fmt.Errorf("proto: wrong wireType = %d for field PreferredVersion", wireType)
				3318	}
				3319	var msglen int
				3320	for shift := uint(0); ; shift += 7 {
				3321	if shift >= 64 {
				3322	return ErrIntOverflowGenerated
				3323	}
				3324	if iNdEx >= l {
				3325	return io.ErrUnexpectedEOF
				3326	}
				3327	b := dAtA[iNdEx]
				3328	iNdEx++
				3329	msglen \|= (int(b) & 0x7F) << shift
				3330	if b < 0x80 {
				3331	break
				3332	}
				3333	}
				3334	if msglen < 0 {
				3335	return ErrInvalidLengthGenerated
				3336	}
				3337	postIndex := iNdEx + msglen
				3338	if postIndex > l {
				3339	return io.ErrUnexpectedEOF
				3340	}
				3341	if err := m.PreferredVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3342	return err
				3343	}
				3344	iNdEx = postIndex
				3345	case 4:
				3346	if wireType != 2 {
				3347	return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
				3348	}
				3349	var msglen int
				3350	for shift := uint(0); ; shift += 7 {
				3351	if shift >= 64 {
				3352	return ErrIntOverflowGenerated
				3353	}
				3354	if iNdEx >= l {
				3355	return io.ErrUnexpectedEOF
				3356	}
				3357	b := dAtA[iNdEx]
				3358	iNdEx++
				3359	msglen \|= (int(b) & 0x7F) << shift
				3360	if b < 0x80 {
				3361	break
				3362	}
				3363	}
				3364	if msglen < 0 {
				3365	return ErrInvalidLengthGenerated
				3366	}
				3367	postIndex := iNdEx + msglen
				3368	if postIndex > l {
				3369	return io.ErrUnexpectedEOF
				3370	}
				3371	m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
				3372	if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3373	return err
				3374	}
				3375	iNdEx = postIndex
				3376	default:
				3377	iNdEx = preIndex
				3378	skippy, err := skipGenerated(dAtA[iNdEx:])
				3379	if err != nil {
				3380	return err
				3381	}
				3382	if skippy < 0 {
				3383	return ErrInvalidLengthGenerated
				3384	}
				3385	if (iNdEx + skippy) > l {
				3386	return io.ErrUnexpectedEOF
				3387	}
				3388	iNdEx += skippy
				3389	}
				3390	}
				3391
				3392	if iNdEx > l {
				3393	return io.ErrUnexpectedEOF
				3394	}
				3395	return nil
				3396	}
				3397	func (m *APIGroupList) Unmarshal(dAtA []byte) error {
				3398	l := len(dAtA)
				3399	iNdEx := 0
				3400	for iNdEx < l {
				3401	preIndex := iNdEx
				3402	var wire uint64
				3403	for shift := uint(0); ; shift += 7 {
				3404	if shift >= 64 {
				3405	return ErrIntOverflowGenerated
				3406	}
				3407	if iNdEx >= l {
				3408	return io.ErrUnexpectedEOF
				3409	}
				3410	b := dAtA[iNdEx]
				3411	iNdEx++
				3412	wire \|= (uint64(b) & 0x7F) << shift
				3413	if b < 0x80 {
				3414	break
				3415	}
				3416	}
				3417	fieldNum := int32(wire >> 3)
				3418	wireType := int(wire & 0x7)
				3419	if wireType == 4 {
				3420	return fmt.Errorf("proto: APIGroupList: wiretype end group for non-group")
				3421	}
				3422	if fieldNum <= 0 {
				3423	return fmt.Errorf("proto: APIGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
				3424	}
				3425	switch fieldNum {
				3426	case 1:
				3427	if wireType != 2 {
				3428	return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
				3429	}
				3430	var msglen int
				3431	for shift := uint(0); ; shift += 7 {
				3432	if shift >= 64 {
				3433	return ErrIntOverflowGenerated
				3434	}
				3435	if iNdEx >= l {
				3436	return io.ErrUnexpectedEOF
				3437	}
				3438	b := dAtA[iNdEx]
				3439	iNdEx++
				3440	msglen \|= (int(b) & 0x7F) << shift
				3441	if b < 0x80 {
				3442	break
				3443	}
				3444	}
				3445	if msglen < 0 {
				3446	return ErrInvalidLengthGenerated
				3447	}
				3448	postIndex := iNdEx + msglen
				3449	if postIndex > l {
				3450	return io.ErrUnexpectedEOF
				3451	}
				3452	m.Groups = append(m.Groups, APIGroup{})
				3453	if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3454	return err
				3455	}
				3456	iNdEx = postIndex
				3457	default:
				3458	iNdEx = preIndex
				3459	skippy, err := skipGenerated(dAtA[iNdEx:])
				3460	if err != nil {
				3461	return err
				3462	}
				3463	if skippy < 0 {
				3464	return ErrInvalidLengthGenerated
				3465	}
				3466	if (iNdEx + skippy) > l {
				3467	return io.ErrUnexpectedEOF
				3468	}
				3469	iNdEx += skippy
				3470	}
				3471	}
				3472
				3473	if iNdEx > l {
				3474	return io.ErrUnexpectedEOF
				3475	}
				3476	return nil
				3477	}
				3478	func (m *APIResource) Unmarshal(dAtA []byte) error {
				3479	l := len(dAtA)
				3480	iNdEx := 0
				3481	for iNdEx < l {
				3482	preIndex := iNdEx
				3483	var wire uint64
				3484	for shift := uint(0); ; shift += 7 {
				3485	if shift >= 64 {
				3486	return ErrIntOverflowGenerated
				3487	}
				3488	if iNdEx >= l {
				3489	return io.ErrUnexpectedEOF
				3490	}
				3491	b := dAtA[iNdEx]
				3492	iNdEx++
				3493	wire \|= (uint64(b) & 0x7F) << shift
				3494	if b < 0x80 {
				3495	break
				3496	}
				3497	}
				3498	fieldNum := int32(wire >> 3)
				3499	wireType := int(wire & 0x7)
				3500	if wireType == 4 {
				3501	return fmt.Errorf("proto: APIResource: wiretype end group for non-group")
				3502	}
				3503	if fieldNum <= 0 {
				3504	return fmt.Errorf("proto: APIResource: illegal tag %d (wire type %d)", fieldNum, wire)
				3505	}
				3506	switch fieldNum {
				3507	case 1:
				3508	if wireType != 2 {
				3509	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				3510	}
				3511	var stringLen uint64
				3512	for shift := uint(0); ; shift += 7 {
				3513	if shift >= 64 {
				3514	return ErrIntOverflowGenerated
				3515	}
				3516	if iNdEx >= l {
				3517	return io.ErrUnexpectedEOF
				3518	}
				3519	b := dAtA[iNdEx]
				3520	iNdEx++
				3521	stringLen \|= (uint64(b) & 0x7F) << shift
				3522	if b < 0x80 {
				3523	break
				3524	}
				3525	}
				3526	intStringLen := int(stringLen)
				3527	if intStringLen < 0 {
				3528	return ErrInvalidLengthGenerated
				3529	}
				3530	postIndex := iNdEx + intStringLen
				3531	if postIndex > l {
				3532	return io.ErrUnexpectedEOF
				3533	}
				3534	m.Name = string(dAtA[iNdEx:postIndex])
				3535	iNdEx = postIndex
				3536	case 2:
				3537	if wireType != 0 {
				3538	return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", wireType)
				3539	}
				3540	var v int
				3541	for shift := uint(0); ; shift += 7 {
				3542	if shift >= 64 {
				3543	return ErrIntOverflowGenerated
				3544	}
				3545	if iNdEx >= l {
				3546	return io.ErrUnexpectedEOF
				3547	}
				3548	b := dAtA[iNdEx]
				3549	iNdEx++
				3550	v \|= (int(b) & 0x7F) << shift
				3551	if b < 0x80 {
				3552	break
				3553	}
				3554	}
				3555	m.Namespaced = bool(v != 0)
				3556	case 3:
				3557	if wireType != 2 {
				3558	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				3559	}
				3560	var stringLen uint64
				3561	for shift := uint(0); ; shift += 7 {
				3562	if shift >= 64 {
				3563	return ErrIntOverflowGenerated
				3564	}
				3565	if iNdEx >= l {
				3566	return io.ErrUnexpectedEOF
				3567	}
				3568	b := dAtA[iNdEx]
				3569	iNdEx++
				3570	stringLen \|= (uint64(b) & 0x7F) << shift
				3571	if b < 0x80 {
				3572	break
				3573	}
				3574	}
				3575	intStringLen := int(stringLen)
				3576	if intStringLen < 0 {
				3577	return ErrInvalidLengthGenerated
				3578	}
				3579	postIndex := iNdEx + intStringLen
				3580	if postIndex > l {
				3581	return io.ErrUnexpectedEOF
				3582	}
				3583	m.Kind = string(dAtA[iNdEx:postIndex])
				3584	iNdEx = postIndex
				3585	case 4:
				3586	if wireType != 2 {
				3587	return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
				3588	}
				3589	var msglen int
				3590	for shift := uint(0); ; shift += 7 {
				3591	if shift >= 64 {
				3592	return ErrIntOverflowGenerated
				3593	}
				3594	if iNdEx >= l {
				3595	return io.ErrUnexpectedEOF
				3596	}
				3597	b := dAtA[iNdEx]
				3598	iNdEx++
				3599	msglen \|= (int(b) & 0x7F) << shift
				3600	if b < 0x80 {
				3601	break
				3602	}
				3603	}
				3604	if msglen < 0 {
				3605	return ErrInvalidLengthGenerated
				3606	}
				3607	postIndex := iNdEx + msglen
				3608	if postIndex > l {
				3609	return io.ErrUnexpectedEOF
				3610	}
				3611	if m.Verbs == nil {
				3612	m.Verbs = Verbs{}
				3613	}
				3614	if err := m.Verbs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3615	return err
				3616	}
				3617	iNdEx = postIndex
				3618	case 5:
				3619	if wireType != 2 {
				3620	return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType)
				3621	}
				3622	var stringLen uint64
				3623	for shift := uint(0); ; shift += 7 {
				3624	if shift >= 64 {
				3625	return ErrIntOverflowGenerated
				3626	}
				3627	if iNdEx >= l {
				3628	return io.ErrUnexpectedEOF
				3629	}
				3630	b := dAtA[iNdEx]
				3631	iNdEx++
				3632	stringLen \|= (uint64(b) & 0x7F) << shift
				3633	if b < 0x80 {
				3634	break
				3635	}
				3636	}
				3637	intStringLen := int(stringLen)
				3638	if intStringLen < 0 {
				3639	return ErrInvalidLengthGenerated
				3640	}
				3641	postIndex := iNdEx + intStringLen
				3642	if postIndex > l {
				3643	return io.ErrUnexpectedEOF
				3644	}
				3645	m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex]))
				3646	iNdEx = postIndex
				3647	case 6:
				3648	if wireType != 2 {
				3649	return fmt.Errorf("proto: wrong wireType = %d for field SingularName", wireType)
				3650	}
				3651	var stringLen uint64
				3652	for shift := uint(0); ; shift += 7 {
				3653	if shift >= 64 {
				3654	return ErrIntOverflowGenerated
				3655	}
				3656	if iNdEx >= l {
				3657	return io.ErrUnexpectedEOF
				3658	}
				3659	b := dAtA[iNdEx]
				3660	iNdEx++
				3661	stringLen \|= (uint64(b) & 0x7F) << shift
				3662	if b < 0x80 {
				3663	break
				3664	}
				3665	}
				3666	intStringLen := int(stringLen)
				3667	if intStringLen < 0 {
				3668	return ErrInvalidLengthGenerated
				3669	}
				3670	postIndex := iNdEx + intStringLen
				3671	if postIndex > l {
				3672	return io.ErrUnexpectedEOF
				3673	}
				3674	m.SingularName = string(dAtA[iNdEx:postIndex])
				3675	iNdEx = postIndex
				3676	case 7:
				3677	if wireType != 2 {
				3678	return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
				3679	}
				3680	var stringLen uint64
				3681	for shift := uint(0); ; shift += 7 {
				3682	if shift >= 64 {
				3683	return ErrIntOverflowGenerated
				3684	}
				3685	if iNdEx >= l {
				3686	return io.ErrUnexpectedEOF
				3687	}
				3688	b := dAtA[iNdEx]
				3689	iNdEx++
				3690	stringLen \|= (uint64(b) & 0x7F) << shift
				3691	if b < 0x80 {
				3692	break
				3693	}
				3694	}
				3695	intStringLen := int(stringLen)
				3696	if intStringLen < 0 {
				3697	return ErrInvalidLengthGenerated
				3698	}
				3699	postIndex := iNdEx + intStringLen
				3700	if postIndex > l {
				3701	return io.ErrUnexpectedEOF
				3702	}
				3703	m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
				3704	iNdEx = postIndex
				3705	case 8:
				3706	if wireType != 2 {
				3707	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				3708	}
				3709	var stringLen uint64
				3710	for shift := uint(0); ; shift += 7 {
				3711	if shift >= 64 {
				3712	return ErrIntOverflowGenerated
				3713	}
				3714	if iNdEx >= l {
				3715	return io.ErrUnexpectedEOF
				3716	}
				3717	b := dAtA[iNdEx]
				3718	iNdEx++
				3719	stringLen \|= (uint64(b) & 0x7F) << shift
				3720	if b < 0x80 {
				3721	break
				3722	}
				3723	}
				3724	intStringLen := int(stringLen)
				3725	if intStringLen < 0 {
				3726	return ErrInvalidLengthGenerated
				3727	}
				3728	postIndex := iNdEx + intStringLen
				3729	if postIndex > l {
				3730	return io.ErrUnexpectedEOF
				3731	}
				3732	m.Group = string(dAtA[iNdEx:postIndex])
				3733	iNdEx = postIndex
				3734	case 9:
				3735	if wireType != 2 {
				3736	return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
				3737	}
				3738	var stringLen uint64
				3739	for shift := uint(0); ; shift += 7 {
				3740	if shift >= 64 {
				3741	return ErrIntOverflowGenerated
				3742	}
				3743	if iNdEx >= l {
				3744	return io.ErrUnexpectedEOF
				3745	}
				3746	b := dAtA[iNdEx]
				3747	iNdEx++
				3748	stringLen \|= (uint64(b) & 0x7F) << shift
				3749	if b < 0x80 {
				3750	break
				3751	}
				3752	}
				3753	intStringLen := int(stringLen)
				3754	if intStringLen < 0 {
				3755	return ErrInvalidLengthGenerated
				3756	}
				3757	postIndex := iNdEx + intStringLen
				3758	if postIndex > l {
				3759	return io.ErrUnexpectedEOF
				3760	}
				3761	m.Version = string(dAtA[iNdEx:postIndex])
				3762	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	3763	case 10:
				3764	if wireType != 2 {
				3765	return fmt.Errorf("proto: wrong wireType = %d for field StorageVersionHash", wireType)
				3766	}
				3767	var stringLen uint64
				3768	for shift := uint(0); ; shift += 7 {
				3769	if shift >= 64 {
				3770	return ErrIntOverflowGenerated
				3771	}
				3772	if iNdEx >= l {
				3773	return io.ErrUnexpectedEOF
				3774	}
				3775	b := dAtA[iNdEx]
				3776	iNdEx++
				3777	stringLen \|= (uint64(b) & 0x7F) << shift
				3778	if b < 0x80 {
				3779	break
				3780	}
				3781	}
				3782	intStringLen := int(stringLen)
				3783	if intStringLen < 0 {
				3784	return ErrInvalidLengthGenerated
				3785	}
				3786	postIndex := iNdEx + intStringLen
				3787	if postIndex > l {
				3788	return io.ErrUnexpectedEOF
				3789	}
				3790	m.StorageVersionHash = string(dAtA[iNdEx:postIndex])
				3791	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	3792	default:
				3793	iNdEx = preIndex
				3794	skippy, err := skipGenerated(dAtA[iNdEx:])
				3795	if err != nil {
				3796	return err
				3797	}
				3798	if skippy < 0 {
				3799	return ErrInvalidLengthGenerated
				3800	}
				3801	if (iNdEx + skippy) > l {
				3802	return io.ErrUnexpectedEOF
				3803	}
				3804	iNdEx += skippy
				3805	}
				3806	}
				3807
				3808	if iNdEx > l {
				3809	return io.ErrUnexpectedEOF
				3810	}
				3811	return nil
				3812	}
				3813	func (m *APIResourceList) Unmarshal(dAtA []byte) error {
				3814	l := len(dAtA)
				3815	iNdEx := 0
				3816	for iNdEx < l {
				3817	preIndex := iNdEx
				3818	var wire uint64
				3819	for shift := uint(0); ; shift += 7 {
				3820	if shift >= 64 {
				3821	return ErrIntOverflowGenerated
				3822	}
				3823	if iNdEx >= l {
				3824	return io.ErrUnexpectedEOF
				3825	}
				3826	b := dAtA[iNdEx]
				3827	iNdEx++
				3828	wire \|= (uint64(b) & 0x7F) << shift
				3829	if b < 0x80 {
				3830	break
				3831	}
				3832	}
				3833	fieldNum := int32(wire >> 3)
				3834	wireType := int(wire & 0x7)
				3835	if wireType == 4 {
				3836	return fmt.Errorf("proto: APIResourceList: wiretype end group for non-group")
				3837	}
				3838	if fieldNum <= 0 {
				3839	return fmt.Errorf("proto: APIResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
				3840	}
				3841	switch fieldNum {
				3842	case 1:
				3843	if wireType != 2 {
				3844	return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
				3845	}
				3846	var stringLen uint64
				3847	for shift := uint(0); ; shift += 7 {
				3848	if shift >= 64 {
				3849	return ErrIntOverflowGenerated
				3850	}
				3851	if iNdEx >= l {
				3852	return io.ErrUnexpectedEOF
				3853	}
				3854	b := dAtA[iNdEx]
				3855	iNdEx++
				3856	stringLen \|= (uint64(b) & 0x7F) << shift
				3857	if b < 0x80 {
				3858	break
				3859	}
				3860	}
				3861	intStringLen := int(stringLen)
				3862	if intStringLen < 0 {
				3863	return ErrInvalidLengthGenerated
				3864	}
				3865	postIndex := iNdEx + intStringLen
				3866	if postIndex > l {
				3867	return io.ErrUnexpectedEOF
				3868	}
				3869	m.GroupVersion = string(dAtA[iNdEx:postIndex])
				3870	iNdEx = postIndex
				3871	case 2:
				3872	if wireType != 2 {
				3873	return fmt.Errorf("proto: wrong wireType = %d for field APIResources", wireType)
				3874	}
				3875	var msglen int
				3876	for shift := uint(0); ; shift += 7 {
				3877	if shift >= 64 {
				3878	return ErrIntOverflowGenerated
				3879	}
				3880	if iNdEx >= l {
				3881	return io.ErrUnexpectedEOF
				3882	}
				3883	b := dAtA[iNdEx]
				3884	iNdEx++
				3885	msglen \|= (int(b) & 0x7F) << shift
				3886	if b < 0x80 {
				3887	break
				3888	}
				3889	}
				3890	if msglen < 0 {
				3891	return ErrInvalidLengthGenerated
				3892	}
				3893	postIndex := iNdEx + msglen
				3894	if postIndex > l {
				3895	return io.ErrUnexpectedEOF
				3896	}
				3897	m.APIResources = append(m.APIResources, APIResource{})
				3898	if err := m.APIResources[len(m.APIResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				3899	return err
				3900	}
				3901	iNdEx = postIndex
				3902	default:
				3903	iNdEx = preIndex
				3904	skippy, err := skipGenerated(dAtA[iNdEx:])
				3905	if err != nil {
				3906	return err
				3907	}
				3908	if skippy < 0 {
				3909	return ErrInvalidLengthGenerated
				3910	}
				3911	if (iNdEx + skippy) > l {
				3912	return io.ErrUnexpectedEOF
				3913	}
				3914	iNdEx += skippy
				3915	}
				3916	}
				3917
				3918	if iNdEx > l {
				3919	return io.ErrUnexpectedEOF
				3920	}
				3921	return nil
				3922	}
				3923	func (m *APIVersions) Unmarshal(dAtA []byte) error {
				3924	l := len(dAtA)
				3925	iNdEx := 0
				3926	for iNdEx < l {
				3927	preIndex := iNdEx
				3928	var wire uint64
				3929	for shift := uint(0); ; shift += 7 {
				3930	if shift >= 64 {
				3931	return ErrIntOverflowGenerated
				3932	}
				3933	if iNdEx >= l {
				3934	return io.ErrUnexpectedEOF
				3935	}
				3936	b := dAtA[iNdEx]
				3937	iNdEx++
				3938	wire \|= (uint64(b) & 0x7F) << shift
				3939	if b < 0x80 {
				3940	break
				3941	}
				3942	}
				3943	fieldNum := int32(wire >> 3)
				3944	wireType := int(wire & 0x7)
				3945	if wireType == 4 {
				3946	return fmt.Errorf("proto: APIVersions: wiretype end group for non-group")
				3947	}
				3948	if fieldNum <= 0 {
				3949	return fmt.Errorf("proto: APIVersions: illegal tag %d (wire type %d)", fieldNum, wire)
				3950	}
				3951	switch fieldNum {
				3952	case 1:
				3953	if wireType != 2 {
				3954	return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
				3955	}
				3956	var stringLen uint64
				3957	for shift := uint(0); ; shift += 7 {
				3958	if shift >= 64 {
				3959	return ErrIntOverflowGenerated
				3960	}
				3961	if iNdEx >= l {
				3962	return io.ErrUnexpectedEOF
				3963	}
				3964	b := dAtA[iNdEx]
				3965	iNdEx++
				3966	stringLen \|= (uint64(b) & 0x7F) << shift
				3967	if b < 0x80 {
				3968	break
				3969	}
				3970	}
				3971	intStringLen := int(stringLen)
				3972	if intStringLen < 0 {
				3973	return ErrInvalidLengthGenerated
				3974	}
				3975	postIndex := iNdEx + intStringLen
				3976	if postIndex > l {
				3977	return io.ErrUnexpectedEOF
				3978	}
				3979	m.Versions = append(m.Versions, string(dAtA[iNdEx:postIndex]))
				3980	iNdEx = postIndex
				3981	case 2:
				3982	if wireType != 2 {
				3983	return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
				3984	}
				3985	var msglen int
				3986	for shift := uint(0); ; shift += 7 {
				3987	if shift >= 64 {
				3988	return ErrIntOverflowGenerated
				3989	}
				3990	if iNdEx >= l {
				3991	return io.ErrUnexpectedEOF
				3992	}
				3993	b := dAtA[iNdEx]
				3994	iNdEx++
				3995	msglen \|= (int(b) & 0x7F) << shift
				3996	if b < 0x80 {
				3997	break
				3998	}
				3999	}
				4000	if msglen < 0 {
				4001	return ErrInvalidLengthGenerated
				4002	}
				4003	postIndex := iNdEx + msglen
				4004	if postIndex > l {
				4005	return io.ErrUnexpectedEOF
				4006	}
				4007	m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
				4008	if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				4009	return err
				4010	}
				4011	iNdEx = postIndex
				4012	default:
				4013	iNdEx = preIndex
				4014	skippy, err := skipGenerated(dAtA[iNdEx:])
				4015	if err != nil {
				4016	return err
				4017	}
				4018	if skippy < 0 {
				4019	return ErrInvalidLengthGenerated
				4020	}
				4021	if (iNdEx + skippy) > l {
				4022	return io.ErrUnexpectedEOF
				4023	}
				4024	iNdEx += skippy
				4025	}
				4026	}
				4027
				4028	if iNdEx > l {
				4029	return io.ErrUnexpectedEOF
				4030	}
				4031	return nil
				4032	}
				4033	func (m *CreateOptions) Unmarshal(dAtA []byte) error {
				4034	l := len(dAtA)
				4035	iNdEx := 0
				4036	for iNdEx < l {
				4037	preIndex := iNdEx
				4038	var wire uint64
				4039	for shift := uint(0); ; shift += 7 {
				4040	if shift >= 64 {
				4041	return ErrIntOverflowGenerated
				4042	}
				4043	if iNdEx >= l {
				4044	return io.ErrUnexpectedEOF
				4045	}
				4046	b := dAtA[iNdEx]
				4047	iNdEx++
				4048	wire \|= (uint64(b) & 0x7F) << shift
				4049	if b < 0x80 {
				4050	break
				4051	}
				4052	}
				4053	fieldNum := int32(wire >> 3)
				4054	wireType := int(wire & 0x7)
				4055	if wireType == 4 {
				4056	return fmt.Errorf("proto: CreateOptions: wiretype end group for non-group")
				4057	}
				4058	if fieldNum <= 0 {
				4059	return fmt.Errorf("proto: CreateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				4060	}
				4061	switch fieldNum {
				4062	case 1:
				4063	if wireType != 2 {
				4064	return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
				4065	}
				4066	var stringLen uint64
				4067	for shift := uint(0); ; shift += 7 {
				4068	if shift >= 64 {
				4069	return ErrIntOverflowGenerated
				4070	}
				4071	if iNdEx >= l {
				4072	return io.ErrUnexpectedEOF
				4073	}
				4074	b := dAtA[iNdEx]
				4075	iNdEx++
				4076	stringLen \|= (uint64(b) & 0x7F) << shift
				4077	if b < 0x80 {
				4078	break
				4079	}
				4080	}
				4081	intStringLen := int(stringLen)
				4082	if intStringLen < 0 {
				4083	return ErrInvalidLengthGenerated
				4084	}
				4085	postIndex := iNdEx + intStringLen
				4086	if postIndex > l {
				4087	return io.ErrUnexpectedEOF
				4088	}
				4089	m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
				4090	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	4091	case 3:
				4092	if wireType != 2 {
				4093	return fmt.Errorf("proto: wrong wireType = %d for field FieldManager", wireType)
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4094	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	4095	var stringLen uint64
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4096	for shift := uint(0); ; shift += 7 {
				4097	if shift >= 64 {
				4098	return ErrIntOverflowGenerated
				4099	}
				4100	if iNdEx >= l {
				4101	return io.ErrUnexpectedEOF
				4102	}
				4103	b := dAtA[iNdEx]
				4104	iNdEx++
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	4105	stringLen \|= (uint64(b) & 0x7F) << shift
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4106	if b < 0x80 {
				4107	break
				4108	}
				4109	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	4110	intStringLen := int(stringLen)
				4111	if intStringLen < 0 {
				4112	return ErrInvalidLengthGenerated
				4113	}
				4114	postIndex := iNdEx + intStringLen
				4115	if postIndex > l {
				4116	return io.ErrUnexpectedEOF
				4117	}
				4118	m.FieldManager = string(dAtA[iNdEx:postIndex])
				4119	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4120	default:
				4121	iNdEx = preIndex
				4122	skippy, err := skipGenerated(dAtA[iNdEx:])
				4123	if err != nil {
				4124	return err
				4125	}
				4126	if skippy < 0 {
				4127	return ErrInvalidLengthGenerated
				4128	}
				4129	if (iNdEx + skippy) > l {
				4130	return io.ErrUnexpectedEOF
				4131	}
				4132	iNdEx += skippy
				4133	}
				4134	}
				4135
				4136	if iNdEx > l {
				4137	return io.ErrUnexpectedEOF
				4138	}
				4139	return nil
				4140	}
				4141	func (m *DeleteOptions) Unmarshal(dAtA []byte) error {
				4142	l := len(dAtA)
				4143	iNdEx := 0
				4144	for iNdEx < l {
				4145	preIndex := iNdEx
				4146	var wire uint64
				4147	for shift := uint(0); ; shift += 7 {
				4148	if shift >= 64 {
				4149	return ErrIntOverflowGenerated
				4150	}
				4151	if iNdEx >= l {
				4152	return io.ErrUnexpectedEOF
				4153	}
				4154	b := dAtA[iNdEx]
				4155	iNdEx++
				4156	wire \|= (uint64(b) & 0x7F) << shift
				4157	if b < 0x80 {
				4158	break
				4159	}
				4160	}
				4161	fieldNum := int32(wire >> 3)
				4162	wireType := int(wire & 0x7)
				4163	if wireType == 4 {
				4164	return fmt.Errorf("proto: DeleteOptions: wiretype end group for non-group")
				4165	}
				4166	if fieldNum <= 0 {
				4167	return fmt.Errorf("proto: DeleteOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				4168	}
				4169	switch fieldNum {
				4170	case 1:
				4171	if wireType != 0 {
				4172	return fmt.Errorf("proto: wrong wireType = %d for field GracePeriodSeconds", wireType)
				4173	}
				4174	var v int64
				4175	for shift := uint(0); ; shift += 7 {
				4176	if shift >= 64 {
				4177	return ErrIntOverflowGenerated
				4178	}
				4179	if iNdEx >= l {
				4180	return io.ErrUnexpectedEOF
				4181	}
				4182	b := dAtA[iNdEx]
				4183	iNdEx++
				4184	v \|= (int64(b) & 0x7F) << shift
				4185	if b < 0x80 {
				4186	break
				4187	}
				4188	}
				4189	m.GracePeriodSeconds = &v
				4190	case 2:
				4191	if wireType != 2 {
				4192	return fmt.Errorf("proto: wrong wireType = %d for field Preconditions", wireType)
				4193	}
				4194	var msglen int
				4195	for shift := uint(0); ; shift += 7 {
				4196	if shift >= 64 {
				4197	return ErrIntOverflowGenerated
				4198	}
				4199	if iNdEx >= l {
				4200	return io.ErrUnexpectedEOF
				4201	}
				4202	b := dAtA[iNdEx]
				4203	iNdEx++
				4204	msglen \|= (int(b) & 0x7F) << shift
				4205	if b < 0x80 {
				4206	break
				4207	}
				4208	}
				4209	if msglen < 0 {
				4210	return ErrInvalidLengthGenerated
				4211	}
				4212	postIndex := iNdEx + msglen
				4213	if postIndex > l {
				4214	return io.ErrUnexpectedEOF
				4215	}
				4216	if m.Preconditions == nil {
				4217	m.Preconditions = &Preconditions{}
				4218	}
				4219	if err := m.Preconditions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				4220	return err
				4221	}
				4222	iNdEx = postIndex
				4223	case 3:
				4224	if wireType != 0 {
				4225	return fmt.Errorf("proto: wrong wireType = %d for field OrphanDependents", wireType)
				4226	}
				4227	var v int
				4228	for shift := uint(0); ; shift += 7 {
				4229	if shift >= 64 {
				4230	return ErrIntOverflowGenerated
				4231	}
				4232	if iNdEx >= l {
				4233	return io.ErrUnexpectedEOF
				4234	}
				4235	b := dAtA[iNdEx]
				4236	iNdEx++
				4237	v \|= (int(b) & 0x7F) << shift
				4238	if b < 0x80 {
				4239	break
				4240	}
				4241	}
				4242	b := bool(v != 0)
				4243	m.OrphanDependents = &b
				4244	case 4:
				4245	if wireType != 2 {
				4246	return fmt.Errorf("proto: wrong wireType = %d for field PropagationPolicy", wireType)
				4247	}
				4248	var stringLen uint64
				4249	for shift := uint(0); ; shift += 7 {
				4250	if shift >= 64 {
				4251	return ErrIntOverflowGenerated
				4252	}
				4253	if iNdEx >= l {
				4254	return io.ErrUnexpectedEOF
				4255	}
				4256	b := dAtA[iNdEx]
				4257	iNdEx++
				4258	stringLen \|= (uint64(b) & 0x7F) << shift
				4259	if b < 0x80 {
				4260	break
				4261	}
				4262	}
				4263	intStringLen := int(stringLen)
				4264	if intStringLen < 0 {
				4265	return ErrInvalidLengthGenerated
				4266	}
				4267	postIndex := iNdEx + intStringLen
				4268	if postIndex > l {
				4269	return io.ErrUnexpectedEOF
				4270	}
				4271	s := DeletionPropagation(dAtA[iNdEx:postIndex])
				4272	m.PropagationPolicy = &s
				4273	iNdEx = postIndex
				4274	case 5:
				4275	if wireType != 2 {
				4276	return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
				4277	}
				4278	var stringLen uint64
				4279	for shift := uint(0); ; shift += 7 {
				4280	if shift >= 64 {
				4281	return ErrIntOverflowGenerated
				4282	}
				4283	if iNdEx >= l {
				4284	return io.ErrUnexpectedEOF
				4285	}
				4286	b := dAtA[iNdEx]
				4287	iNdEx++
				4288	stringLen \|= (uint64(b) & 0x7F) << shift
				4289	if b < 0x80 {
				4290	break
				4291	}
				4292	}
				4293	intStringLen := int(stringLen)
				4294	if intStringLen < 0 {
				4295	return ErrInvalidLengthGenerated
				4296	}
				4297	postIndex := iNdEx + intStringLen
				4298	if postIndex > l {
				4299	return io.ErrUnexpectedEOF
				4300	}
				4301	m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
				4302	iNdEx = postIndex
				4303	default:
				4304	iNdEx = preIndex
				4305	skippy, err := skipGenerated(dAtA[iNdEx:])
				4306	if err != nil {
				4307	return err
				4308	}
				4309	if skippy < 0 {
				4310	return ErrInvalidLengthGenerated
				4311	}
				4312	if (iNdEx + skippy) > l {
				4313	return io.ErrUnexpectedEOF
				4314	}
				4315	iNdEx += skippy
				4316	}
				4317	}
				4318
				4319	if iNdEx > l {
				4320	return io.ErrUnexpectedEOF
				4321	}
				4322	return nil
				4323	}
				4324	func (m *Duration) Unmarshal(dAtA []byte) error {
				4325	l := len(dAtA)
				4326	iNdEx := 0
				4327	for iNdEx < l {
				4328	preIndex := iNdEx
				4329	var wire uint64
				4330	for shift := uint(0); ; shift += 7 {
				4331	if shift >= 64 {
				4332	return ErrIntOverflowGenerated
				4333	}
				4334	if iNdEx >= l {
				4335	return io.ErrUnexpectedEOF
				4336	}
				4337	b := dAtA[iNdEx]
				4338	iNdEx++
				4339	wire \|= (uint64(b) & 0x7F) << shift
				4340	if b < 0x80 {
				4341	break
				4342	}
				4343	}
				4344	fieldNum := int32(wire >> 3)
				4345	wireType := int(wire & 0x7)
				4346	if wireType == 4 {
				4347	return fmt.Errorf("proto: Duration: wiretype end group for non-group")
				4348	}
				4349	if fieldNum <= 0 {
				4350	return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire)
				4351	}
				4352	switch fieldNum {
				4353	case 1:
				4354	if wireType != 0 {
				4355	return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
				4356	}
				4357	m.Duration = 0
				4358	for shift := uint(0); ; shift += 7 {
				4359	if shift >= 64 {
				4360	return ErrIntOverflowGenerated
				4361	}
				4362	if iNdEx >= l {
				4363	return io.ErrUnexpectedEOF
				4364	}
				4365	b := dAtA[iNdEx]
				4366	iNdEx++
				4367	m.Duration \|= (time.Duration(b) & 0x7F) << shift
				4368	if b < 0x80 {
				4369	break
				4370	}
				4371	}
				4372	default:
				4373	iNdEx = preIndex
				4374	skippy, err := skipGenerated(dAtA[iNdEx:])
				4375	if err != nil {
				4376	return err
				4377	}
				4378	if skippy < 0 {
				4379	return ErrInvalidLengthGenerated
				4380	}
				4381	if (iNdEx + skippy) > l {
				4382	return io.ErrUnexpectedEOF
				4383	}
				4384	iNdEx += skippy
				4385	}
				4386	}
				4387
				4388	if iNdEx > l {
				4389	return io.ErrUnexpectedEOF
				4390	}
				4391	return nil
				4392	}
				4393	func (m *ExportOptions) Unmarshal(dAtA []byte) error {
				4394	l := len(dAtA)
				4395	iNdEx := 0
				4396	for iNdEx < l {
				4397	preIndex := iNdEx
				4398	var wire uint64
				4399	for shift := uint(0); ; shift += 7 {
				4400	if shift >= 64 {
				4401	return ErrIntOverflowGenerated
				4402	}
				4403	if iNdEx >= l {
				4404	return io.ErrUnexpectedEOF
				4405	}
				4406	b := dAtA[iNdEx]
				4407	iNdEx++
				4408	wire \|= (uint64(b) & 0x7F) << shift
				4409	if b < 0x80 {
				4410	break
				4411	}
				4412	}
				4413	fieldNum := int32(wire >> 3)
				4414	wireType := int(wire & 0x7)
				4415	if wireType == 4 {
				4416	return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
				4417	}
				4418	if fieldNum <= 0 {
				4419	return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				4420	}
				4421	switch fieldNum {
				4422	case 1:
				4423	if wireType != 0 {
				4424	return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
				4425	}
				4426	var v int
				4427	for shift := uint(0); ; shift += 7 {
				4428	if shift >= 64 {
				4429	return ErrIntOverflowGenerated
				4430	}
				4431	if iNdEx >= l {
				4432	return io.ErrUnexpectedEOF
				4433	}
				4434	b := dAtA[iNdEx]
				4435	iNdEx++
				4436	v \|= (int(b) & 0x7F) << shift
				4437	if b < 0x80 {
				4438	break
				4439	}
				4440	}
				4441	m.Export = bool(v != 0)
				4442	case 2:
				4443	if wireType != 0 {
				4444	return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
				4445	}
				4446	var v int
				4447	for shift := uint(0); ; shift += 7 {
				4448	if shift >= 64 {
				4449	return ErrIntOverflowGenerated
				4450	}
				4451	if iNdEx >= l {
				4452	return io.ErrUnexpectedEOF
				4453	}
				4454	b := dAtA[iNdEx]
				4455	iNdEx++
				4456	v \|= (int(b) & 0x7F) << shift
				4457	if b < 0x80 {
				4458	break
				4459	}
				4460	}
				4461	m.Exact = bool(v != 0)
				4462	default:
				4463	iNdEx = preIndex
				4464	skippy, err := skipGenerated(dAtA[iNdEx:])
				4465	if err != nil {
				4466	return err
				4467	}
				4468	if skippy < 0 {
				4469	return ErrInvalidLengthGenerated
				4470	}
				4471	if (iNdEx + skippy) > l {
				4472	return io.ErrUnexpectedEOF
				4473	}
				4474	iNdEx += skippy
				4475	}
				4476	}
				4477
				4478	if iNdEx > l {
				4479	return io.ErrUnexpectedEOF
				4480	}
				4481	return nil
				4482	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	4483	func (m *Fields) Unmarshal(dAtA []byte) error {
				4484	l := len(dAtA)
				4485	iNdEx := 0
				4486	for iNdEx < l {
				4487	preIndex := iNdEx
				4488	var wire uint64
				4489	for shift := uint(0); ; shift += 7 {
				4490	if shift >= 64 {
				4491	return ErrIntOverflowGenerated
				4492	}
				4493	if iNdEx >= l {
				4494	return io.ErrUnexpectedEOF
				4495	}
				4496	b := dAtA[iNdEx]
				4497	iNdEx++
				4498	wire \|= (uint64(b) & 0x7F) << shift
				4499	if b < 0x80 {
				4500	break
				4501	}
				4502	}
				4503	fieldNum := int32(wire >> 3)
				4504	wireType := int(wire & 0x7)
				4505	if wireType == 4 {
				4506	return fmt.Errorf("proto: Fields: wiretype end group for non-group")
				4507	}
				4508	if fieldNum <= 0 {
				4509	return fmt.Errorf("proto: Fields: illegal tag %d (wire type %d)", fieldNum, wire)
				4510	}
				4511	switch fieldNum {
				4512	case 1:
				4513	if wireType != 2 {
				4514	return fmt.Errorf("proto: wrong wireType = %d for field Map", wireType)
				4515	}
				4516	var msglen int
				4517	for shift := uint(0); ; shift += 7 {
				4518	if shift >= 64 {
				4519	return ErrIntOverflowGenerated
				4520	}
				4521	if iNdEx >= l {
				4522	return io.ErrUnexpectedEOF
				4523	}
				4524	b := dAtA[iNdEx]
				4525	iNdEx++
				4526	msglen \|= (int(b) & 0x7F) << shift
				4527	if b < 0x80 {
				4528	break
				4529	}
				4530	}
				4531	if msglen < 0 {
				4532	return ErrInvalidLengthGenerated
				4533	}
				4534	postIndex := iNdEx + msglen
				4535	if postIndex > l {
				4536	return io.ErrUnexpectedEOF
				4537	}
				4538	if m.Map == nil {
				4539	m.Map = make(map[string]Fields)
				4540	}
				4541	var mapkey string
				4542	mapvalue := &Fields{}
				4543	for iNdEx < postIndex {
				4544	entryPreIndex := iNdEx
				4545	var wire uint64
				4546	for shift := uint(0); ; shift += 7 {
				4547	if shift >= 64 {
				4548	return ErrIntOverflowGenerated
				4549	}
				4550	if iNdEx >= l {
				4551	return io.ErrUnexpectedEOF
				4552	}
				4553	b := dAtA[iNdEx]
				4554	iNdEx++
				4555	wire \|= (uint64(b) & 0x7F) << shift
				4556	if b < 0x80 {
				4557	break
				4558	}
				4559	}
				4560	fieldNum := int32(wire >> 3)
				4561	if fieldNum == 1 {
				4562	var stringLenmapkey uint64
				4563	for shift := uint(0); ; shift += 7 {
				4564	if shift >= 64 {
				4565	return ErrIntOverflowGenerated
				4566	}
				4567	if iNdEx >= l {
				4568	return io.ErrUnexpectedEOF
				4569	}
				4570	b := dAtA[iNdEx]
				4571	iNdEx++
				4572	stringLenmapkey \|= (uint64(b) & 0x7F) << shift
				4573	if b < 0x80 {
				4574	break
				4575	}
				4576	}
				4577	intStringLenmapkey := int(stringLenmapkey)
				4578	if intStringLenmapkey < 0 {
				4579	return ErrInvalidLengthGenerated
				4580	}
				4581	postStringIndexmapkey := iNdEx + intStringLenmapkey
				4582	if postStringIndexmapkey > l {
				4583	return io.ErrUnexpectedEOF
				4584	}
				4585	mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
				4586	iNdEx = postStringIndexmapkey
				4587	} else if fieldNum == 2 {
				4588	var mapmsglen int
				4589	for shift := uint(0); ; shift += 7 {
				4590	if shift >= 64 {
				4591	return ErrIntOverflowGenerated
				4592	}
				4593	if iNdEx >= l {
				4594	return io.ErrUnexpectedEOF
				4595	}
				4596	b := dAtA[iNdEx]
				4597	iNdEx++
				4598	mapmsglen \|= (int(b) & 0x7F) << shift
				4599	if b < 0x80 {
				4600	break
				4601	}
				4602	}
				4603	if mapmsglen < 0 {
				4604	return ErrInvalidLengthGenerated
				4605	}
				4606	postmsgIndex := iNdEx + mapmsglen
				4607	if mapmsglen < 0 {
				4608	return ErrInvalidLengthGenerated
				4609	}
				4610	if postmsgIndex > l {
				4611	return io.ErrUnexpectedEOF
				4612	}
				4613	mapvalue = &Fields{}
				4614	if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
				4615	return err
				4616	}
				4617	iNdEx = postmsgIndex
				4618	} else {
				4619	iNdEx = entryPreIndex
				4620	skippy, err := skipGenerated(dAtA[iNdEx:])
				4621	if err != nil {
				4622	return err
				4623	}
				4624	if skippy < 0 {
				4625	return ErrInvalidLengthGenerated
				4626	}
				4627	if (iNdEx + skippy) > postIndex {
				4628	return io.ErrUnexpectedEOF
				4629	}
				4630	iNdEx += skippy
				4631	}
				4632	}
				4633	m.Map[mapkey] = *mapvalue
				4634	iNdEx = postIndex
				4635	default:
				4636	iNdEx = preIndex
				4637	skippy, err := skipGenerated(dAtA[iNdEx:])
				4638	if err != nil {
				4639	return err
				4640	}
				4641	if skippy < 0 {
				4642	return ErrInvalidLengthGenerated
				4643	}
				4644	if (iNdEx + skippy) > l {
				4645	return io.ErrUnexpectedEOF
				4646	}
				4647	iNdEx += skippy
				4648	}
				4649	}
				4650
				4651	if iNdEx > l {
				4652	return io.ErrUnexpectedEOF
				4653	}
				4654	return nil
				4655	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4656	func (m *GetOptions) Unmarshal(dAtA []byte) error {
				4657	l := len(dAtA)
				4658	iNdEx := 0
				4659	for iNdEx < l {
				4660	preIndex := iNdEx
				4661	var wire uint64
				4662	for shift := uint(0); ; shift += 7 {
				4663	if shift >= 64 {
				4664	return ErrIntOverflowGenerated
				4665	}
				4666	if iNdEx >= l {
				4667	return io.ErrUnexpectedEOF
				4668	}
				4669	b := dAtA[iNdEx]
				4670	iNdEx++
				4671	wire \|= (uint64(b) & 0x7F) << shift
				4672	if b < 0x80 {
				4673	break
				4674	}
				4675	}
				4676	fieldNum := int32(wire >> 3)
				4677	wireType := int(wire & 0x7)
				4678	if wireType == 4 {
				4679	return fmt.Errorf("proto: GetOptions: wiretype end group for non-group")
				4680	}
				4681	if fieldNum <= 0 {
				4682	return fmt.Errorf("proto: GetOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				4683	}
				4684	switch fieldNum {
				4685	case 1:
				4686	if wireType != 2 {
				4687	return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
				4688	}
				4689	var stringLen uint64
				4690	for shift := uint(0); ; shift += 7 {
				4691	if shift >= 64 {
				4692	return ErrIntOverflowGenerated
				4693	}
				4694	if iNdEx >= l {
				4695	return io.ErrUnexpectedEOF
				4696	}
				4697	b := dAtA[iNdEx]
				4698	iNdEx++
				4699	stringLen \|= (uint64(b) & 0x7F) << shift
				4700	if b < 0x80 {
				4701	break
				4702	}
				4703	}
				4704	intStringLen := int(stringLen)
				4705	if intStringLen < 0 {
				4706	return ErrInvalidLengthGenerated
				4707	}
				4708	postIndex := iNdEx + intStringLen
				4709	if postIndex > l {
				4710	return io.ErrUnexpectedEOF
				4711	}
				4712	m.ResourceVersion = string(dAtA[iNdEx:postIndex])
				4713	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	4714	default:
				4715	iNdEx = preIndex
				4716	skippy, err := skipGenerated(dAtA[iNdEx:])
				4717	if err != nil {
				4718	return err
				4719	}
				4720	if skippy < 0 {
				4721	return ErrInvalidLengthGenerated
				4722	}
				4723	if (iNdEx + skippy) > l {
				4724	return io.ErrUnexpectedEOF
				4725	}
				4726	iNdEx += skippy
				4727	}
				4728	}
				4729
				4730	if iNdEx > l {
				4731	return io.ErrUnexpectedEOF
				4732	}
				4733	return nil
				4734	}
				4735	func (m *GroupKind) Unmarshal(dAtA []byte) error {
				4736	l := len(dAtA)
				4737	iNdEx := 0
				4738	for iNdEx < l {
				4739	preIndex := iNdEx
				4740	var wire uint64
				4741	for shift := uint(0); ; shift += 7 {
				4742	if shift >= 64 {
				4743	return ErrIntOverflowGenerated
				4744	}
				4745	if iNdEx >= l {
				4746	return io.ErrUnexpectedEOF
				4747	}
				4748	b := dAtA[iNdEx]
				4749	iNdEx++
				4750	wire \|= (uint64(b) & 0x7F) << shift
				4751	if b < 0x80 {
				4752	break
				4753	}
				4754	}
				4755	fieldNum := int32(wire >> 3)
				4756	wireType := int(wire & 0x7)
				4757	if wireType == 4 {
				4758	return fmt.Errorf("proto: GroupKind: wiretype end group for non-group")
				4759	}
				4760	if fieldNum <= 0 {
				4761	return fmt.Errorf("proto: GroupKind: illegal tag %d (wire type %d)", fieldNum, wire)
				4762	}
				4763	switch fieldNum {
				4764	case 1:
				4765	if wireType != 2 {
				4766	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				4767	}
				4768	var stringLen uint64
				4769	for shift := uint(0); ; shift += 7 {
				4770	if shift >= 64 {
				4771	return ErrIntOverflowGenerated
				4772	}
				4773	if iNdEx >= l {
				4774	return io.ErrUnexpectedEOF
				4775	}
				4776	b := dAtA[iNdEx]
				4777	iNdEx++
				4778	stringLen \|= (uint64(b) & 0x7F) << shift
				4779	if b < 0x80 {
				4780	break
				4781	}
				4782	}
				4783	intStringLen := int(stringLen)
				4784	if intStringLen < 0 {
				4785	return ErrInvalidLengthGenerated
				4786	}
				4787	postIndex := iNdEx + intStringLen
				4788	if postIndex > l {
				4789	return io.ErrUnexpectedEOF
				4790	}
				4791	m.Group = string(dAtA[iNdEx:postIndex])
				4792	iNdEx = postIndex
				4793	case 2:
				4794	if wireType != 2 {
				4795	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				4796	}
				4797	var stringLen uint64
				4798	for shift := uint(0); ; shift += 7 {
				4799	if shift >= 64 {
				4800	return ErrIntOverflowGenerated
				4801	}
				4802	if iNdEx >= l {
				4803	return io.ErrUnexpectedEOF
				4804	}
				4805	b := dAtA[iNdEx]
				4806	iNdEx++
				4807	stringLen \|= (uint64(b) & 0x7F) << shift
				4808	if b < 0x80 {
				4809	break
				4810	}
				4811	}
				4812	intStringLen := int(stringLen)
				4813	if intStringLen < 0 {
				4814	return ErrInvalidLengthGenerated
				4815	}
				4816	postIndex := iNdEx + intStringLen
				4817	if postIndex > l {
				4818	return io.ErrUnexpectedEOF
				4819	}
				4820	m.Kind = string(dAtA[iNdEx:postIndex])
				4821	iNdEx = postIndex
				4822	default:
				4823	iNdEx = preIndex
				4824	skippy, err := skipGenerated(dAtA[iNdEx:])
				4825	if err != nil {
				4826	return err
				4827	}
				4828	if skippy < 0 {
				4829	return ErrInvalidLengthGenerated
				4830	}
				4831	if (iNdEx + skippy) > l {
				4832	return io.ErrUnexpectedEOF
				4833	}
				4834	iNdEx += skippy
				4835	}
				4836	}
				4837
				4838	if iNdEx > l {
				4839	return io.ErrUnexpectedEOF
				4840	}
				4841	return nil
				4842	}
				4843	func (m *GroupResource) Unmarshal(dAtA []byte) error {
				4844	l := len(dAtA)
				4845	iNdEx := 0
				4846	for iNdEx < l {
				4847	preIndex := iNdEx
				4848	var wire uint64
				4849	for shift := uint(0); ; shift += 7 {
				4850	if shift >= 64 {
				4851	return ErrIntOverflowGenerated
				4852	}
				4853	if iNdEx >= l {
				4854	return io.ErrUnexpectedEOF
				4855	}
				4856	b := dAtA[iNdEx]
				4857	iNdEx++
				4858	wire \|= (uint64(b) & 0x7F) << shift
				4859	if b < 0x80 {
				4860	break
				4861	}
				4862	}
				4863	fieldNum := int32(wire >> 3)
				4864	wireType := int(wire & 0x7)
				4865	if wireType == 4 {
				4866	return fmt.Errorf("proto: GroupResource: wiretype end group for non-group")
				4867	}
				4868	if fieldNum <= 0 {
				4869	return fmt.Errorf("proto: GroupResource: illegal tag %d (wire type %d)", fieldNum, wire)
				4870	}
				4871	switch fieldNum {
				4872	case 1:
				4873	if wireType != 2 {
				4874	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				4875	}
				4876	var stringLen uint64
				4877	for shift := uint(0); ; shift += 7 {
				4878	if shift >= 64 {
				4879	return ErrIntOverflowGenerated
				4880	}
				4881	if iNdEx >= l {
				4882	return io.ErrUnexpectedEOF
				4883	}
				4884	b := dAtA[iNdEx]
				4885	iNdEx++
				4886	stringLen \|= (uint64(b) & 0x7F) << shift
				4887	if b < 0x80 {
				4888	break
				4889	}
				4890	}
				4891	intStringLen := int(stringLen)
				4892	if intStringLen < 0 {
				4893	return ErrInvalidLengthGenerated
				4894	}
				4895	postIndex := iNdEx + intStringLen
				4896	if postIndex > l {
				4897	return io.ErrUnexpectedEOF
				4898	}
				4899	m.Group = string(dAtA[iNdEx:postIndex])
				4900	iNdEx = postIndex
				4901	case 2:
				4902	if wireType != 2 {
				4903	return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
				4904	}
				4905	var stringLen uint64
				4906	for shift := uint(0); ; shift += 7 {
				4907	if shift >= 64 {
				4908	return ErrIntOverflowGenerated
				4909	}
				4910	if iNdEx >= l {
				4911	return io.ErrUnexpectedEOF
				4912	}
				4913	b := dAtA[iNdEx]
				4914	iNdEx++
				4915	stringLen \|= (uint64(b) & 0x7F) << shift
				4916	if b < 0x80 {
				4917	break
				4918	}
				4919	}
				4920	intStringLen := int(stringLen)
				4921	if intStringLen < 0 {
				4922	return ErrInvalidLengthGenerated
				4923	}
				4924	postIndex := iNdEx + intStringLen
				4925	if postIndex > l {
				4926	return io.ErrUnexpectedEOF
				4927	}
				4928	m.Resource = string(dAtA[iNdEx:postIndex])
				4929	iNdEx = postIndex
				4930	default:
				4931	iNdEx = preIndex
				4932	skippy, err := skipGenerated(dAtA[iNdEx:])
				4933	if err != nil {
				4934	return err
				4935	}
				4936	if skippy < 0 {
				4937	return ErrInvalidLengthGenerated
				4938	}
				4939	if (iNdEx + skippy) > l {
				4940	return io.ErrUnexpectedEOF
				4941	}
				4942	iNdEx += skippy
				4943	}
				4944	}
				4945
				4946	if iNdEx > l {
				4947	return io.ErrUnexpectedEOF
				4948	}
				4949	return nil
				4950	}
				4951	func (m *GroupVersion) Unmarshal(dAtA []byte) error {
				4952	l := len(dAtA)
				4953	iNdEx := 0
				4954	for iNdEx < l {
				4955	preIndex := iNdEx
				4956	var wire uint64
				4957	for shift := uint(0); ; shift += 7 {
				4958	if shift >= 64 {
				4959	return ErrIntOverflowGenerated
				4960	}
				4961	if iNdEx >= l {
				4962	return io.ErrUnexpectedEOF
				4963	}
				4964	b := dAtA[iNdEx]
				4965	iNdEx++
				4966	wire \|= (uint64(b) & 0x7F) << shift
				4967	if b < 0x80 {
				4968	break
				4969	}
				4970	}
				4971	fieldNum := int32(wire >> 3)
				4972	wireType := int(wire & 0x7)
				4973	if wireType == 4 {
				4974	return fmt.Errorf("proto: GroupVersion: wiretype end group for non-group")
				4975	}
				4976	if fieldNum <= 0 {
				4977	return fmt.Errorf("proto: GroupVersion: illegal tag %d (wire type %d)", fieldNum, wire)
				4978	}
				4979	switch fieldNum {
				4980	case 1:
				4981	if wireType != 2 {
				4982	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				4983	}
				4984	var stringLen uint64
				4985	for shift := uint(0); ; shift += 7 {
				4986	if shift >= 64 {
				4987	return ErrIntOverflowGenerated
				4988	}
				4989	if iNdEx >= l {
				4990	return io.ErrUnexpectedEOF
				4991	}
				4992	b := dAtA[iNdEx]
				4993	iNdEx++
				4994	stringLen \|= (uint64(b) & 0x7F) << shift
				4995	if b < 0x80 {
				4996	break
				4997	}
				4998	}
				4999	intStringLen := int(stringLen)
				5000	if intStringLen < 0 {
				5001	return ErrInvalidLengthGenerated
				5002	}
				5003	postIndex := iNdEx + intStringLen
				5004	if postIndex > l {
				5005	return io.ErrUnexpectedEOF
				5006	}
				5007	m.Group = string(dAtA[iNdEx:postIndex])
				5008	iNdEx = postIndex
				5009	case 2:
				5010	if wireType != 2 {
				5011	return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
				5012	}
				5013	var stringLen uint64
				5014	for shift := uint(0); ; shift += 7 {
				5015	if shift >= 64 {
				5016	return ErrIntOverflowGenerated
				5017	}
				5018	if iNdEx >= l {
				5019	return io.ErrUnexpectedEOF
				5020	}
				5021	b := dAtA[iNdEx]
				5022	iNdEx++
				5023	stringLen \|= (uint64(b) & 0x7F) << shift
				5024	if b < 0x80 {
				5025	break
				5026	}
				5027	}
				5028	intStringLen := int(stringLen)
				5029	if intStringLen < 0 {
				5030	return ErrInvalidLengthGenerated
				5031	}
				5032	postIndex := iNdEx + intStringLen
				5033	if postIndex > l {
				5034	return io.ErrUnexpectedEOF
				5035	}
				5036	m.Version = string(dAtA[iNdEx:postIndex])
				5037	iNdEx = postIndex
				5038	default:
				5039	iNdEx = preIndex
				5040	skippy, err := skipGenerated(dAtA[iNdEx:])
				5041	if err != nil {
				5042	return err
				5043	}
				5044	if skippy < 0 {
				5045	return ErrInvalidLengthGenerated
				5046	}
				5047	if (iNdEx + skippy) > l {
				5048	return io.ErrUnexpectedEOF
				5049	}
				5050	iNdEx += skippy
				5051	}
				5052	}
				5053
				5054	if iNdEx > l {
				5055	return io.ErrUnexpectedEOF
				5056	}
				5057	return nil
				5058	}
				5059	func (m *GroupVersionForDiscovery) Unmarshal(dAtA []byte) error {
				5060	l := len(dAtA)
				5061	iNdEx := 0
				5062	for iNdEx < l {
				5063	preIndex := iNdEx
				5064	var wire uint64
				5065	for shift := uint(0); ; shift += 7 {
				5066	if shift >= 64 {
				5067	return ErrIntOverflowGenerated
				5068	}
				5069	if iNdEx >= l {
				5070	return io.ErrUnexpectedEOF
				5071	}
				5072	b := dAtA[iNdEx]
				5073	iNdEx++
				5074	wire \|= (uint64(b) & 0x7F) << shift
				5075	if b < 0x80 {
				5076	break
				5077	}
				5078	}
				5079	fieldNum := int32(wire >> 3)
				5080	wireType := int(wire & 0x7)
				5081	if wireType == 4 {
				5082	return fmt.Errorf("proto: GroupVersionForDiscovery: wiretype end group for non-group")
				5083	}
				5084	if fieldNum <= 0 {
				5085	return fmt.Errorf("proto: GroupVersionForDiscovery: illegal tag %d (wire type %d)", fieldNum, wire)
				5086	}
				5087	switch fieldNum {
				5088	case 1:
				5089	if wireType != 2 {
				5090	return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
				5091	}
				5092	var stringLen uint64
				5093	for shift := uint(0); ; shift += 7 {
				5094	if shift >= 64 {
				5095	return ErrIntOverflowGenerated
				5096	}
				5097	if iNdEx >= l {
				5098	return io.ErrUnexpectedEOF
				5099	}
				5100	b := dAtA[iNdEx]
				5101	iNdEx++
				5102	stringLen \|= (uint64(b) & 0x7F) << shift
				5103	if b < 0x80 {
				5104	break
				5105	}
				5106	}
				5107	intStringLen := int(stringLen)
				5108	if intStringLen < 0 {
				5109	return ErrInvalidLengthGenerated
				5110	}
				5111	postIndex := iNdEx + intStringLen
				5112	if postIndex > l {
				5113	return io.ErrUnexpectedEOF
				5114	}
				5115	m.GroupVersion = string(dAtA[iNdEx:postIndex])
				5116	iNdEx = postIndex
				5117	case 2:
				5118	if wireType != 2 {
				5119	return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
				5120	}
				5121	var stringLen uint64
				5122	for shift := uint(0); ; shift += 7 {
				5123	if shift >= 64 {
				5124	return ErrIntOverflowGenerated
				5125	}
				5126	if iNdEx >= l {
				5127	return io.ErrUnexpectedEOF
				5128	}
				5129	b := dAtA[iNdEx]
				5130	iNdEx++
				5131	stringLen \|= (uint64(b) & 0x7F) << shift
				5132	if b < 0x80 {
				5133	break
				5134	}
				5135	}
				5136	intStringLen := int(stringLen)
				5137	if intStringLen < 0 {
				5138	return ErrInvalidLengthGenerated
				5139	}
				5140	postIndex := iNdEx + intStringLen
				5141	if postIndex > l {
				5142	return io.ErrUnexpectedEOF
				5143	}
				5144	m.Version = string(dAtA[iNdEx:postIndex])
				5145	iNdEx = postIndex
				5146	default:
				5147	iNdEx = preIndex
				5148	skippy, err := skipGenerated(dAtA[iNdEx:])
				5149	if err != nil {
				5150	return err
				5151	}
				5152	if skippy < 0 {
				5153	return ErrInvalidLengthGenerated
				5154	}
				5155	if (iNdEx + skippy) > l {
				5156	return io.ErrUnexpectedEOF
				5157	}
				5158	iNdEx += skippy
				5159	}
				5160	}
				5161
				5162	if iNdEx > l {
				5163	return io.ErrUnexpectedEOF
				5164	}
				5165	return nil
				5166	}
				5167	func (m *GroupVersionKind) Unmarshal(dAtA []byte) error {
				5168	l := len(dAtA)
				5169	iNdEx := 0
				5170	for iNdEx < l {
				5171	preIndex := iNdEx
				5172	var wire uint64
				5173	for shift := uint(0); ; shift += 7 {
				5174	if shift >= 64 {
				5175	return ErrIntOverflowGenerated
				5176	}
				5177	if iNdEx >= l {
				5178	return io.ErrUnexpectedEOF
				5179	}
				5180	b := dAtA[iNdEx]
				5181	iNdEx++
				5182	wire \|= (uint64(b) & 0x7F) << shift
				5183	if b < 0x80 {
				5184	break
				5185	}
				5186	}
				5187	fieldNum := int32(wire >> 3)
				5188	wireType := int(wire & 0x7)
				5189	if wireType == 4 {
				5190	return fmt.Errorf("proto: GroupVersionKind: wiretype end group for non-group")
				5191	}
				5192	if fieldNum <= 0 {
				5193	return fmt.Errorf("proto: GroupVersionKind: illegal tag %d (wire type %d)", fieldNum, wire)
				5194	}
				5195	switch fieldNum {
				5196	case 1:
				5197	if wireType != 2 {
				5198	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				5199	}
				5200	var stringLen uint64
				5201	for shift := uint(0); ; shift += 7 {
				5202	if shift >= 64 {
				5203	return ErrIntOverflowGenerated
				5204	}
				5205	if iNdEx >= l {
				5206	return io.ErrUnexpectedEOF
				5207	}
				5208	b := dAtA[iNdEx]
				5209	iNdEx++
				5210	stringLen \|= (uint64(b) & 0x7F) << shift
				5211	if b < 0x80 {
				5212	break
				5213	}
				5214	}
				5215	intStringLen := int(stringLen)
				5216	if intStringLen < 0 {
				5217	return ErrInvalidLengthGenerated
				5218	}
				5219	postIndex := iNdEx + intStringLen
				5220	if postIndex > l {
				5221	return io.ErrUnexpectedEOF
				5222	}
				5223	m.Group = string(dAtA[iNdEx:postIndex])
				5224	iNdEx = postIndex
				5225	case 2:
				5226	if wireType != 2 {
				5227	return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
				5228	}
				5229	var stringLen uint64
				5230	for shift := uint(0); ; shift += 7 {
				5231	if shift >= 64 {
				5232	return ErrIntOverflowGenerated
				5233	}
				5234	if iNdEx >= l {
				5235	return io.ErrUnexpectedEOF
				5236	}
				5237	b := dAtA[iNdEx]
				5238	iNdEx++
				5239	stringLen \|= (uint64(b) & 0x7F) << shift
				5240	if b < 0x80 {
				5241	break
				5242	}
				5243	}
				5244	intStringLen := int(stringLen)
				5245	if intStringLen < 0 {
				5246	return ErrInvalidLengthGenerated
				5247	}
				5248	postIndex := iNdEx + intStringLen
				5249	if postIndex > l {
				5250	return io.ErrUnexpectedEOF
				5251	}
				5252	m.Version = string(dAtA[iNdEx:postIndex])
				5253	iNdEx = postIndex
				5254	case 3:
				5255	if wireType != 2 {
				5256	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				5257	}
				5258	var stringLen uint64
				5259	for shift := uint(0); ; shift += 7 {
				5260	if shift >= 64 {
				5261	return ErrIntOverflowGenerated
				5262	}
				5263	if iNdEx >= l {
				5264	return io.ErrUnexpectedEOF
				5265	}
				5266	b := dAtA[iNdEx]
				5267	iNdEx++
				5268	stringLen \|= (uint64(b) & 0x7F) << shift
				5269	if b < 0x80 {
				5270	break
				5271	}
				5272	}
				5273	intStringLen := int(stringLen)
				5274	if intStringLen < 0 {
				5275	return ErrInvalidLengthGenerated
				5276	}
				5277	postIndex := iNdEx + intStringLen
				5278	if postIndex > l {
				5279	return io.ErrUnexpectedEOF
				5280	}
				5281	m.Kind = string(dAtA[iNdEx:postIndex])
				5282	iNdEx = postIndex
				5283	default:
				5284	iNdEx = preIndex
				5285	skippy, err := skipGenerated(dAtA[iNdEx:])
				5286	if err != nil {
				5287	return err
				5288	}
				5289	if skippy < 0 {
				5290	return ErrInvalidLengthGenerated
				5291	}
				5292	if (iNdEx + skippy) > l {
				5293	return io.ErrUnexpectedEOF
				5294	}
				5295	iNdEx += skippy
				5296	}
				5297	}
				5298
				5299	if iNdEx > l {
				5300	return io.ErrUnexpectedEOF
				5301	}
				5302	return nil
				5303	}
				5304	func (m *GroupVersionResource) Unmarshal(dAtA []byte) error {
				5305	l := len(dAtA)
				5306	iNdEx := 0
				5307	for iNdEx < l {
				5308	preIndex := iNdEx
				5309	var wire uint64
				5310	for shift := uint(0); ; shift += 7 {
				5311	if shift >= 64 {
				5312	return ErrIntOverflowGenerated
				5313	}
				5314	if iNdEx >= l {
				5315	return io.ErrUnexpectedEOF
				5316	}
				5317	b := dAtA[iNdEx]
				5318	iNdEx++
				5319	wire \|= (uint64(b) & 0x7F) << shift
				5320	if b < 0x80 {
				5321	break
				5322	}
				5323	}
				5324	fieldNum := int32(wire >> 3)
				5325	wireType := int(wire & 0x7)
				5326	if wireType == 4 {
				5327	return fmt.Errorf("proto: GroupVersionResource: wiretype end group for non-group")
				5328	}
				5329	if fieldNum <= 0 {
				5330	return fmt.Errorf("proto: GroupVersionResource: illegal tag %d (wire type %d)", fieldNum, wire)
				5331	}
				5332	switch fieldNum {
				5333	case 1:
				5334	if wireType != 2 {
				5335	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				5336	}
				5337	var stringLen uint64
				5338	for shift := uint(0); ; shift += 7 {
				5339	if shift >= 64 {
				5340	return ErrIntOverflowGenerated
				5341	}
				5342	if iNdEx >= l {
				5343	return io.ErrUnexpectedEOF
				5344	}
				5345	b := dAtA[iNdEx]
				5346	iNdEx++
				5347	stringLen \|= (uint64(b) & 0x7F) << shift
				5348	if b < 0x80 {
				5349	break
				5350	}
				5351	}
				5352	intStringLen := int(stringLen)
				5353	if intStringLen < 0 {
				5354	return ErrInvalidLengthGenerated
				5355	}
				5356	postIndex := iNdEx + intStringLen
				5357	if postIndex > l {
				5358	return io.ErrUnexpectedEOF
				5359	}
				5360	m.Group = string(dAtA[iNdEx:postIndex])
				5361	iNdEx = postIndex
				5362	case 2:
				5363	if wireType != 2 {
				5364	return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
				5365	}
				5366	var stringLen uint64
				5367	for shift := uint(0); ; shift += 7 {
				5368	if shift >= 64 {
				5369	return ErrIntOverflowGenerated
				5370	}
				5371	if iNdEx >= l {
				5372	return io.ErrUnexpectedEOF
				5373	}
				5374	b := dAtA[iNdEx]
				5375	iNdEx++
				5376	stringLen \|= (uint64(b) & 0x7F) << shift
				5377	if b < 0x80 {
				5378	break
				5379	}
				5380	}
				5381	intStringLen := int(stringLen)
				5382	if intStringLen < 0 {
				5383	return ErrInvalidLengthGenerated
				5384	}
				5385	postIndex := iNdEx + intStringLen
				5386	if postIndex > l {
				5387	return io.ErrUnexpectedEOF
				5388	}
				5389	m.Version = string(dAtA[iNdEx:postIndex])
				5390	iNdEx = postIndex
				5391	case 3:
				5392	if wireType != 2 {
				5393	return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
				5394	}
				5395	var stringLen uint64
				5396	for shift := uint(0); ; shift += 7 {
				5397	if shift >= 64 {
				5398	return ErrIntOverflowGenerated
				5399	}
				5400	if iNdEx >= l {
				5401	return io.ErrUnexpectedEOF
				5402	}
				5403	b := dAtA[iNdEx]
				5404	iNdEx++
				5405	stringLen \|= (uint64(b) & 0x7F) << shift
				5406	if b < 0x80 {
				5407	break
				5408	}
				5409	}
				5410	intStringLen := int(stringLen)
				5411	if intStringLen < 0 {
				5412	return ErrInvalidLengthGenerated
				5413	}
				5414	postIndex := iNdEx + intStringLen
				5415	if postIndex > l {
				5416	return io.ErrUnexpectedEOF
				5417	}
				5418	m.Resource = string(dAtA[iNdEx:postIndex])
				5419	iNdEx = postIndex
				5420	default:
				5421	iNdEx = preIndex
				5422	skippy, err := skipGenerated(dAtA[iNdEx:])
				5423	if err != nil {
				5424	return err
				5425	}
				5426	if skippy < 0 {
				5427	return ErrInvalidLengthGenerated
				5428	}
				5429	if (iNdEx + skippy) > l {
				5430	return io.ErrUnexpectedEOF
				5431	}
				5432	iNdEx += skippy
				5433	}
				5434	}
				5435
				5436	if iNdEx > l {
				5437	return io.ErrUnexpectedEOF
				5438	}
				5439	return nil
				5440	}
				5441	func (m *Initializer) Unmarshal(dAtA []byte) error {
				5442	l := len(dAtA)
				5443	iNdEx := 0
				5444	for iNdEx < l {
				5445	preIndex := iNdEx
				5446	var wire uint64
				5447	for shift := uint(0); ; shift += 7 {
				5448	if shift >= 64 {
				5449	return ErrIntOverflowGenerated
				5450	}
				5451	if iNdEx >= l {
				5452	return io.ErrUnexpectedEOF
				5453	}
				5454	b := dAtA[iNdEx]
				5455	iNdEx++
				5456	wire \|= (uint64(b) & 0x7F) << shift
				5457	if b < 0x80 {
				5458	break
				5459	}
				5460	}
				5461	fieldNum := int32(wire >> 3)
				5462	wireType := int(wire & 0x7)
				5463	if wireType == 4 {
				5464	return fmt.Errorf("proto: Initializer: wiretype end group for non-group")
				5465	}
				5466	if fieldNum <= 0 {
				5467	return fmt.Errorf("proto: Initializer: illegal tag %d (wire type %d)", fieldNum, wire)
				5468	}
				5469	switch fieldNum {
				5470	case 1:
				5471	if wireType != 2 {
				5472	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				5473	}
				5474	var stringLen uint64
				5475	for shift := uint(0); ; shift += 7 {
				5476	if shift >= 64 {
				5477	return ErrIntOverflowGenerated
				5478	}
				5479	if iNdEx >= l {
				5480	return io.ErrUnexpectedEOF
				5481	}
				5482	b := dAtA[iNdEx]
				5483	iNdEx++
				5484	stringLen \|= (uint64(b) & 0x7F) << shift
				5485	if b < 0x80 {
				5486	break
				5487	}
				5488	}
				5489	intStringLen := int(stringLen)
				5490	if intStringLen < 0 {
				5491	return ErrInvalidLengthGenerated
				5492	}
				5493	postIndex := iNdEx + intStringLen
				5494	if postIndex > l {
				5495	return io.ErrUnexpectedEOF
				5496	}
				5497	m.Name = string(dAtA[iNdEx:postIndex])
				5498	iNdEx = postIndex
				5499	default:
				5500	iNdEx = preIndex
				5501	skippy, err := skipGenerated(dAtA[iNdEx:])
				5502	if err != nil {
				5503	return err
				5504	}
				5505	if skippy < 0 {
				5506	return ErrInvalidLengthGenerated
				5507	}
				5508	if (iNdEx + skippy) > l {
				5509	return io.ErrUnexpectedEOF
				5510	}
				5511	iNdEx += skippy
				5512	}
				5513	}
				5514
				5515	if iNdEx > l {
				5516	return io.ErrUnexpectedEOF
				5517	}
				5518	return nil
				5519	}
				5520	func (m *Initializers) Unmarshal(dAtA []byte) error {
				5521	l := len(dAtA)
				5522	iNdEx := 0
				5523	for iNdEx < l {
				5524	preIndex := iNdEx
				5525	var wire uint64
				5526	for shift := uint(0); ; shift += 7 {
				5527	if shift >= 64 {
				5528	return ErrIntOverflowGenerated
				5529	}
				5530	if iNdEx >= l {
				5531	return io.ErrUnexpectedEOF
				5532	}
				5533	b := dAtA[iNdEx]
				5534	iNdEx++
				5535	wire \|= (uint64(b) & 0x7F) << shift
				5536	if b < 0x80 {
				5537	break
				5538	}
				5539	}
				5540	fieldNum := int32(wire >> 3)
				5541	wireType := int(wire & 0x7)
				5542	if wireType == 4 {
				5543	return fmt.Errorf("proto: Initializers: wiretype end group for non-group")
				5544	}
				5545	if fieldNum <= 0 {
				5546	return fmt.Errorf("proto: Initializers: illegal tag %d (wire type %d)", fieldNum, wire)
				5547	}
				5548	switch fieldNum {
				5549	case 1:
				5550	if wireType != 2 {
				5551	return fmt.Errorf("proto: wrong wireType = %d for field Pending", wireType)
				5552	}
				5553	var msglen int
				5554	for shift := uint(0); ; shift += 7 {
				5555	if shift >= 64 {
				5556	return ErrIntOverflowGenerated
				5557	}
				5558	if iNdEx >= l {
				5559	return io.ErrUnexpectedEOF
				5560	}
				5561	b := dAtA[iNdEx]
				5562	iNdEx++
				5563	msglen \|= (int(b) & 0x7F) << shift
				5564	if b < 0x80 {
				5565	break
				5566	}
				5567	}
				5568	if msglen < 0 {
				5569	return ErrInvalidLengthGenerated
				5570	}
				5571	postIndex := iNdEx + msglen
				5572	if postIndex > l {
				5573	return io.ErrUnexpectedEOF
				5574	}
				5575	m.Pending = append(m.Pending, Initializer{})
				5576	if err := m.Pending[len(m.Pending)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				5577	return err
				5578	}
				5579	iNdEx = postIndex
				5580	case 2:
				5581	if wireType != 2 {
				5582	return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
				5583	}
				5584	var msglen int
				5585	for shift := uint(0); ; shift += 7 {
				5586	if shift >= 64 {
				5587	return ErrIntOverflowGenerated
				5588	}
				5589	if iNdEx >= l {
				5590	return io.ErrUnexpectedEOF
				5591	}
				5592	b := dAtA[iNdEx]
				5593	iNdEx++
				5594	msglen \|= (int(b) & 0x7F) << shift
				5595	if b < 0x80 {
				5596	break
				5597	}
				5598	}
				5599	if msglen < 0 {
				5600	return ErrInvalidLengthGenerated
				5601	}
				5602	postIndex := iNdEx + msglen
				5603	if postIndex > l {
				5604	return io.ErrUnexpectedEOF
				5605	}
				5606	if m.Result == nil {
				5607	m.Result = &Status{}
				5608	}
				5609	if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				5610	return err
				5611	}
				5612	iNdEx = postIndex
				5613	default:
				5614	iNdEx = preIndex
				5615	skippy, err := skipGenerated(dAtA[iNdEx:])
				5616	if err != nil {
				5617	return err
				5618	}
				5619	if skippy < 0 {
				5620	return ErrInvalidLengthGenerated
				5621	}
				5622	if (iNdEx + skippy) > l {
				5623	return io.ErrUnexpectedEOF
				5624	}
				5625	iNdEx += skippy
				5626	}
				5627	}
				5628
				5629	if iNdEx > l {
				5630	return io.ErrUnexpectedEOF
				5631	}
				5632	return nil
				5633	}
				5634	func (m *LabelSelector) Unmarshal(dAtA []byte) error {
				5635	l := len(dAtA)
				5636	iNdEx := 0
				5637	for iNdEx < l {
				5638	preIndex := iNdEx
				5639	var wire uint64
				5640	for shift := uint(0); ; shift += 7 {
				5641	if shift >= 64 {
				5642	return ErrIntOverflowGenerated
				5643	}
				5644	if iNdEx >= l {
				5645	return io.ErrUnexpectedEOF
				5646	}
				5647	b := dAtA[iNdEx]
				5648	iNdEx++
				5649	wire \|= (uint64(b) & 0x7F) << shift
				5650	if b < 0x80 {
				5651	break
				5652	}
				5653	}
				5654	fieldNum := int32(wire >> 3)
				5655	wireType := int(wire & 0x7)
				5656	if wireType == 4 {
				5657	return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
				5658	}
				5659	if fieldNum <= 0 {
				5660	return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
				5661	}
				5662	switch fieldNum {
				5663	case 1:
				5664	if wireType != 2 {
				5665	return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
				5666	}
				5667	var msglen int
				5668	for shift := uint(0); ; shift += 7 {
				5669	if shift >= 64 {
				5670	return ErrIntOverflowGenerated
				5671	}
				5672	if iNdEx >= l {
				5673	return io.ErrUnexpectedEOF
				5674	}
				5675	b := dAtA[iNdEx]
				5676	iNdEx++
				5677	msglen \|= (int(b) & 0x7F) << shift
				5678	if b < 0x80 {
				5679	break
				5680	}
				5681	}
				5682	if msglen < 0 {
				5683	return ErrInvalidLengthGenerated
				5684	}
				5685	postIndex := iNdEx + msglen
				5686	if postIndex > l {
				5687	return io.ErrUnexpectedEOF
				5688	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5689	if m.MatchLabels == nil {
				5690	m.MatchLabels = make(map[string]string)
				5691	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5692	var mapkey string
				5693	var mapvalue string
				5694	for iNdEx < postIndex {
				5695	entryPreIndex := iNdEx
				5696	var wire uint64
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5697	for shift := uint(0); ; shift += 7 {
				5698	if shift >= 64 {
				5699	return ErrIntOverflowGenerated
				5700	}
				5701	if iNdEx >= l {
				5702	return io.ErrUnexpectedEOF
				5703	}
				5704	b := dAtA[iNdEx]
				5705	iNdEx++
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5706	wire \|= (uint64(b) & 0x7F) << shift
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5707	if b < 0x80 {
				5708	break
				5709	}
				5710	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5711	fieldNum := int32(wire >> 3)
				5712	if fieldNum == 1 {
				5713	var stringLenmapkey uint64
				5714	for shift := uint(0); ; shift += 7 {
				5715	if shift >= 64 {
				5716	return ErrIntOverflowGenerated
				5717	}
				5718	if iNdEx >= l {
				5719	return io.ErrUnexpectedEOF
				5720	}
				5721	b := dAtA[iNdEx]
				5722	iNdEx++
				5723	stringLenmapkey \|= (uint64(b) & 0x7F) << shift
				5724	if b < 0x80 {
				5725	break
				5726	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5727	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5728	intStringLenmapkey := int(stringLenmapkey)
				5729	if intStringLenmapkey < 0 {
				5730	return ErrInvalidLengthGenerated
				5731	}
				5732	postStringIndexmapkey := iNdEx + intStringLenmapkey
				5733	if postStringIndexmapkey > l {
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5734	return io.ErrUnexpectedEOF
				5735	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5736	mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
				5737	iNdEx = postStringIndexmapkey
				5738	} else if fieldNum == 2 {
				5739	var stringLenmapvalue uint64
				5740	for shift := uint(0); ; shift += 7 {
				5741	if shift >= 64 {
				5742	return ErrIntOverflowGenerated
				5743	}
				5744	if iNdEx >= l {
				5745	return io.ErrUnexpectedEOF
				5746	}
				5747	b := dAtA[iNdEx]
				5748	iNdEx++
				5749	stringLenmapvalue \|= (uint64(b) & 0x7F) << shift
				5750	if b < 0x80 {
				5751	break
				5752	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5753	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5754	intStringLenmapvalue := int(stringLenmapvalue)
				5755	if intStringLenmapvalue < 0 {
				5756	return ErrInvalidLengthGenerated
				5757	}
				5758	postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				5759	if postStringIndexmapvalue > l {
				5760	return io.ErrUnexpectedEOF
				5761	}
				5762	mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
				5763	iNdEx = postStringIndexmapvalue
				5764	} else {
				5765	iNdEx = entryPreIndex
				5766	skippy, err := skipGenerated(dAtA[iNdEx:])
				5767	if err != nil {
				5768	return err
				5769	}
				5770	if skippy < 0 {
				5771	return ErrInvalidLengthGenerated
				5772	}
				5773	if (iNdEx + skippy) > postIndex {
				5774	return io.ErrUnexpectedEOF
				5775	}
				5776	iNdEx += skippy
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5777	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5778	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	5779	m.MatchLabels[mapkey] = mapvalue
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	5780	iNdEx = postIndex
				5781	case 2:
				5782	if wireType != 2 {
				5783	return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
				5784	}
				5785	var msglen int
				5786	for shift := uint(0); ; shift += 7 {
				5787	if shift >= 64 {
				5788	return ErrIntOverflowGenerated
				5789	}
				5790	if iNdEx >= l {
				5791	return io.ErrUnexpectedEOF
				5792	}
				5793	b := dAtA[iNdEx]
				5794	iNdEx++
				5795	msglen \|= (int(b) & 0x7F) << shift
				5796	if b < 0x80 {
				5797	break
				5798	}
				5799	}
				5800	if msglen < 0 {
				5801	return ErrInvalidLengthGenerated
				5802	}
				5803	postIndex := iNdEx + msglen
				5804	if postIndex > l {
				5805	return io.ErrUnexpectedEOF
				5806	}
				5807	m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
				5808	if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				5809	return err
				5810	}
				5811	iNdEx = postIndex
				5812	default:
				5813	iNdEx = preIndex
				5814	skippy, err := skipGenerated(dAtA[iNdEx:])
				5815	if err != nil {
				5816	return err
				5817	}
				5818	if skippy < 0 {
				5819	return ErrInvalidLengthGenerated
				5820	}
				5821	if (iNdEx + skippy) > l {
				5822	return io.ErrUnexpectedEOF
				5823	}
				5824	iNdEx += skippy
				5825	}
				5826	}
				5827
				5828	if iNdEx > l {
				5829	return io.ErrUnexpectedEOF
				5830	}
				5831	return nil
				5832	}
				5833	func (m *LabelSelectorRequirement) Unmarshal(dAtA []byte) error {
				5834	l := len(dAtA)
				5835	iNdEx := 0
				5836	for iNdEx < l {
				5837	preIndex := iNdEx
				5838	var wire uint64
				5839	for shift := uint(0); ; shift += 7 {
				5840	if shift >= 64 {
				5841	return ErrIntOverflowGenerated
				5842	}
				5843	if iNdEx >= l {
				5844	return io.ErrUnexpectedEOF
				5845	}
				5846	b := dAtA[iNdEx]
				5847	iNdEx++
				5848	wire \|= (uint64(b) & 0x7F) << shift
				5849	if b < 0x80 {
				5850	break
				5851	}
				5852	}
				5853	fieldNum := int32(wire >> 3)
				5854	wireType := int(wire & 0x7)
				5855	if wireType == 4 {
				5856	return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
				5857	}
				5858	if fieldNum <= 0 {
				5859	return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
				5860	}
				5861	switch fieldNum {
				5862	case 1:
				5863	if wireType != 2 {
				5864	return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
				5865	}
				5866	var stringLen uint64
				5867	for shift := uint(0); ; shift += 7 {
				5868	if shift >= 64 {
				5869	return ErrIntOverflowGenerated
				5870	}
				5871	if iNdEx >= l {
				5872	return io.ErrUnexpectedEOF
				5873	}
				5874	b := dAtA[iNdEx]
				5875	iNdEx++
				5876	stringLen \|= (uint64(b) & 0x7F) << shift
				5877	if b < 0x80 {
				5878	break
				5879	}
				5880	}
				5881	intStringLen := int(stringLen)
				5882	if intStringLen < 0 {
				5883	return ErrInvalidLengthGenerated
				5884	}
				5885	postIndex := iNdEx + intStringLen
				5886	if postIndex > l {
				5887	return io.ErrUnexpectedEOF
				5888	}
				5889	m.Key = string(dAtA[iNdEx:postIndex])
				5890	iNdEx = postIndex
				5891	case 2:
				5892	if wireType != 2 {
				5893	return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
				5894	}
				5895	var stringLen uint64
				5896	for shift := uint(0); ; shift += 7 {
				5897	if shift >= 64 {
				5898	return ErrIntOverflowGenerated
				5899	}
				5900	if iNdEx >= l {
				5901	return io.ErrUnexpectedEOF
				5902	}
				5903	b := dAtA[iNdEx]
				5904	iNdEx++
				5905	stringLen \|= (uint64(b) & 0x7F) << shift
				5906	if b < 0x80 {
				5907	break
				5908	}
				5909	}
				5910	intStringLen := int(stringLen)
				5911	if intStringLen < 0 {
				5912	return ErrInvalidLengthGenerated
				5913	}
				5914	postIndex := iNdEx + intStringLen
				5915	if postIndex > l {
				5916	return io.ErrUnexpectedEOF
				5917	}
				5918	m.Operator = LabelSelectorOperator(dAtA[iNdEx:postIndex])
				5919	iNdEx = postIndex
				5920	case 3:
				5921	if wireType != 2 {
				5922	return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
				5923	}
				5924	var stringLen uint64
				5925	for shift := uint(0); ; shift += 7 {
				5926	if shift >= 64 {
				5927	return ErrIntOverflowGenerated
				5928	}
				5929	if iNdEx >= l {
				5930	return io.ErrUnexpectedEOF
				5931	}
				5932	b := dAtA[iNdEx]
				5933	iNdEx++
				5934	stringLen \|= (uint64(b) & 0x7F) << shift
				5935	if b < 0x80 {
				5936	break
				5937	}
				5938	}
				5939	intStringLen := int(stringLen)
				5940	if intStringLen < 0 {
				5941	return ErrInvalidLengthGenerated
				5942	}
				5943	postIndex := iNdEx + intStringLen
				5944	if postIndex > l {
				5945	return io.ErrUnexpectedEOF
				5946	}
				5947	m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
				5948	iNdEx = postIndex
				5949	default:
				5950	iNdEx = preIndex
				5951	skippy, err := skipGenerated(dAtA[iNdEx:])
				5952	if err != nil {
				5953	return err
				5954	}
				5955	if skippy < 0 {
				5956	return ErrInvalidLengthGenerated
				5957	}
				5958	if (iNdEx + skippy) > l {
				5959	return io.ErrUnexpectedEOF
				5960	}
				5961	iNdEx += skippy
				5962	}
				5963	}
				5964
				5965	if iNdEx > l {
				5966	return io.ErrUnexpectedEOF
				5967	}
				5968	return nil
				5969	}
				5970	func (m *List) Unmarshal(dAtA []byte) error {
				5971	l := len(dAtA)
				5972	iNdEx := 0
				5973	for iNdEx < l {
				5974	preIndex := iNdEx
				5975	var wire uint64
				5976	for shift := uint(0); ; shift += 7 {
				5977	if shift >= 64 {
				5978	return ErrIntOverflowGenerated
				5979	}
				5980	if iNdEx >= l {
				5981	return io.ErrUnexpectedEOF
				5982	}
				5983	b := dAtA[iNdEx]
				5984	iNdEx++
				5985	wire \|= (uint64(b) & 0x7F) << shift
				5986	if b < 0x80 {
				5987	break
				5988	}
				5989	}
				5990	fieldNum := int32(wire >> 3)
				5991	wireType := int(wire & 0x7)
				5992	if wireType == 4 {
				5993	return fmt.Errorf("proto: List: wiretype end group for non-group")
				5994	}
				5995	if fieldNum <= 0 {
				5996	return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
				5997	}
				5998	switch fieldNum {
				5999	case 1:
				6000	if wireType != 2 {
				6001	return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
				6002	}
				6003	var msglen int
				6004	for shift := uint(0); ; shift += 7 {
				6005	if shift >= 64 {
				6006	return ErrIntOverflowGenerated
				6007	}
				6008	if iNdEx >= l {
				6009	return io.ErrUnexpectedEOF
				6010	}
				6011	b := dAtA[iNdEx]
				6012	iNdEx++
				6013	msglen \|= (int(b) & 0x7F) << shift
				6014	if b < 0x80 {
				6015	break
				6016	}
				6017	}
				6018	if msglen < 0 {
				6019	return ErrInvalidLengthGenerated
				6020	}
				6021	postIndex := iNdEx + msglen
				6022	if postIndex > l {
				6023	return io.ErrUnexpectedEOF
				6024	}
				6025	if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6026	return err
				6027	}
				6028	iNdEx = postIndex
				6029	case 2:
				6030	if wireType != 2 {
				6031	return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
				6032	}
				6033	var msglen int
				6034	for shift := uint(0); ; shift += 7 {
				6035	if shift >= 64 {
				6036	return ErrIntOverflowGenerated
				6037	}
				6038	if iNdEx >= l {
				6039	return io.ErrUnexpectedEOF
				6040	}
				6041	b := dAtA[iNdEx]
				6042	iNdEx++
				6043	msglen \|= (int(b) & 0x7F) << shift
				6044	if b < 0x80 {
				6045	break
				6046	}
				6047	}
				6048	if msglen < 0 {
				6049	return ErrInvalidLengthGenerated
				6050	}
				6051	postIndex := iNdEx + msglen
				6052	if postIndex > l {
				6053	return io.ErrUnexpectedEOF
				6054	}
				6055	m.Items = append(m.Items, k8s_io_apimachinery_pkg_runtime.RawExtension{})
				6056	if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6057	return err
				6058	}
				6059	iNdEx = postIndex
				6060	default:
				6061	iNdEx = preIndex
				6062	skippy, err := skipGenerated(dAtA[iNdEx:])
				6063	if err != nil {
				6064	return err
				6065	}
				6066	if skippy < 0 {
				6067	return ErrInvalidLengthGenerated
				6068	}
				6069	if (iNdEx + skippy) > l {
				6070	return io.ErrUnexpectedEOF
				6071	}
				6072	iNdEx += skippy
				6073	}
				6074	}
				6075
				6076	if iNdEx > l {
				6077	return io.ErrUnexpectedEOF
				6078	}
				6079	return nil
				6080	}
				6081	func (m *ListMeta) Unmarshal(dAtA []byte) error {
				6082	l := len(dAtA)
				6083	iNdEx := 0
				6084	for iNdEx < l {
				6085	preIndex := iNdEx
				6086	var wire uint64
				6087	for shift := uint(0); ; shift += 7 {
				6088	if shift >= 64 {
				6089	return ErrIntOverflowGenerated
				6090	}
				6091	if iNdEx >= l {
				6092	return io.ErrUnexpectedEOF
				6093	}
				6094	b := dAtA[iNdEx]
				6095	iNdEx++
				6096	wire \|= (uint64(b) & 0x7F) << shift
				6097	if b < 0x80 {
				6098	break
				6099	}
				6100	}
				6101	fieldNum := int32(wire >> 3)
				6102	wireType := int(wire & 0x7)
				6103	if wireType == 4 {
				6104	return fmt.Errorf("proto: ListMeta: wiretype end group for non-group")
				6105	}
				6106	if fieldNum <= 0 {
				6107	return fmt.Errorf("proto: ListMeta: illegal tag %d (wire type %d)", fieldNum, wire)
				6108	}
				6109	switch fieldNum {
				6110	case 1:
				6111	if wireType != 2 {
				6112	return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
				6113	}
				6114	var stringLen uint64
				6115	for shift := uint(0); ; shift += 7 {
				6116	if shift >= 64 {
				6117	return ErrIntOverflowGenerated
				6118	}
				6119	if iNdEx >= l {
				6120	return io.ErrUnexpectedEOF
				6121	}
				6122	b := dAtA[iNdEx]
				6123	iNdEx++
				6124	stringLen \|= (uint64(b) & 0x7F) << shift
				6125	if b < 0x80 {
				6126	break
				6127	}
				6128	}
				6129	intStringLen := int(stringLen)
				6130	if intStringLen < 0 {
				6131	return ErrInvalidLengthGenerated
				6132	}
				6133	postIndex := iNdEx + intStringLen
				6134	if postIndex > l {
				6135	return io.ErrUnexpectedEOF
				6136	}
				6137	m.SelfLink = string(dAtA[iNdEx:postIndex])
				6138	iNdEx = postIndex
				6139	case 2:
				6140	if wireType != 2 {
				6141	return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
				6142	}
				6143	var stringLen uint64
				6144	for shift := uint(0); ; shift += 7 {
				6145	if shift >= 64 {
				6146	return ErrIntOverflowGenerated
				6147	}
				6148	if iNdEx >= l {
				6149	return io.ErrUnexpectedEOF
				6150	}
				6151	b := dAtA[iNdEx]
				6152	iNdEx++
				6153	stringLen \|= (uint64(b) & 0x7F) << shift
				6154	if b < 0x80 {
				6155	break
				6156	}
				6157	}
				6158	intStringLen := int(stringLen)
				6159	if intStringLen < 0 {
				6160	return ErrInvalidLengthGenerated
				6161	}
				6162	postIndex := iNdEx + intStringLen
				6163	if postIndex > l {
				6164	return io.ErrUnexpectedEOF
				6165	}
				6166	m.ResourceVersion = string(dAtA[iNdEx:postIndex])
				6167	iNdEx = postIndex
				6168	case 3:
				6169	if wireType != 2 {
				6170	return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
				6171	}
				6172	var stringLen uint64
				6173	for shift := uint(0); ; shift += 7 {
				6174	if shift >= 64 {
				6175	return ErrIntOverflowGenerated
				6176	}
				6177	if iNdEx >= l {
				6178	return io.ErrUnexpectedEOF
				6179	}
				6180	b := dAtA[iNdEx]
				6181	iNdEx++
				6182	stringLen \|= (uint64(b) & 0x7F) << shift
				6183	if b < 0x80 {
				6184	break
				6185	}
				6186	}
				6187	intStringLen := int(stringLen)
				6188	if intStringLen < 0 {
				6189	return ErrInvalidLengthGenerated
				6190	}
				6191	postIndex := iNdEx + intStringLen
				6192	if postIndex > l {
				6193	return io.ErrUnexpectedEOF
				6194	}
				6195	m.Continue = string(dAtA[iNdEx:postIndex])
				6196	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	6197	case 4:
				6198	if wireType != 0 {
				6199	return fmt.Errorf("proto: wrong wireType = %d for field RemainingItemCount", wireType)
				6200	}
				6201	var v int64
				6202	for shift := uint(0); ; shift += 7 {
				6203	if shift >= 64 {
				6204	return ErrIntOverflowGenerated
				6205	}
				6206	if iNdEx >= l {
				6207	return io.ErrUnexpectedEOF
				6208	}
				6209	b := dAtA[iNdEx]
				6210	iNdEx++
				6211	v \|= (int64(b) & 0x7F) << shift
				6212	if b < 0x80 {
				6213	break
				6214	}
				6215	}
				6216	m.RemainingItemCount = &v
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	6217	default:
				6218	iNdEx = preIndex
				6219	skippy, err := skipGenerated(dAtA[iNdEx:])
				6220	if err != nil {
				6221	return err
				6222	}
				6223	if skippy < 0 {
				6224	return ErrInvalidLengthGenerated
				6225	}
				6226	if (iNdEx + skippy) > l {
				6227	return io.ErrUnexpectedEOF
				6228	}
				6229	iNdEx += skippy
				6230	}
				6231	}
				6232
				6233	if iNdEx > l {
				6234	return io.ErrUnexpectedEOF
				6235	}
				6236	return nil
				6237	}
				6238	func (m *ListOptions) Unmarshal(dAtA []byte) error {
				6239	l := len(dAtA)
				6240	iNdEx := 0
				6241	for iNdEx < l {
				6242	preIndex := iNdEx
				6243	var wire uint64
				6244	for shift := uint(0); ; shift += 7 {
				6245	if shift >= 64 {
				6246	return ErrIntOverflowGenerated
				6247	}
				6248	if iNdEx >= l {
				6249	return io.ErrUnexpectedEOF
				6250	}
				6251	b := dAtA[iNdEx]
				6252	iNdEx++
				6253	wire \|= (uint64(b) & 0x7F) << shift
				6254	if b < 0x80 {
				6255	break
				6256	}
				6257	}
				6258	fieldNum := int32(wire >> 3)
				6259	wireType := int(wire & 0x7)
				6260	if wireType == 4 {
				6261	return fmt.Errorf("proto: ListOptions: wiretype end group for non-group")
				6262	}
				6263	if fieldNum <= 0 {
				6264	return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				6265	}
				6266	switch fieldNum {
				6267	case 1:
				6268	if wireType != 2 {
				6269	return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
				6270	}
				6271	var stringLen uint64
				6272	for shift := uint(0); ; shift += 7 {
				6273	if shift >= 64 {
				6274	return ErrIntOverflowGenerated
				6275	}
				6276	if iNdEx >= l {
				6277	return io.ErrUnexpectedEOF
				6278	}
				6279	b := dAtA[iNdEx]
				6280	iNdEx++
				6281	stringLen \|= (uint64(b) & 0x7F) << shift
				6282	if b < 0x80 {
				6283	break
				6284	}
				6285	}
				6286	intStringLen := int(stringLen)
				6287	if intStringLen < 0 {
				6288	return ErrInvalidLengthGenerated
				6289	}
				6290	postIndex := iNdEx + intStringLen
				6291	if postIndex > l {
				6292	return io.ErrUnexpectedEOF
				6293	}
				6294	m.LabelSelector = string(dAtA[iNdEx:postIndex])
				6295	iNdEx = postIndex
				6296	case 2:
				6297	if wireType != 2 {
				6298	return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType)
				6299	}
				6300	var stringLen uint64
				6301	for shift := uint(0); ; shift += 7 {
				6302	if shift >= 64 {
				6303	return ErrIntOverflowGenerated
				6304	}
				6305	if iNdEx >= l {
				6306	return io.ErrUnexpectedEOF
				6307	}
				6308	b := dAtA[iNdEx]
				6309	iNdEx++
				6310	stringLen \|= (uint64(b) & 0x7F) << shift
				6311	if b < 0x80 {
				6312	break
				6313	}
				6314	}
				6315	intStringLen := int(stringLen)
				6316	if intStringLen < 0 {
				6317	return ErrInvalidLengthGenerated
				6318	}
				6319	postIndex := iNdEx + intStringLen
				6320	if postIndex > l {
				6321	return io.ErrUnexpectedEOF
				6322	}
				6323	m.FieldSelector = string(dAtA[iNdEx:postIndex])
				6324	iNdEx = postIndex
				6325	case 3:
				6326	if wireType != 0 {
				6327	return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType)
				6328	}
				6329	var v int
				6330	for shift := uint(0); ; shift += 7 {
				6331	if shift >= 64 {
				6332	return ErrIntOverflowGenerated
				6333	}
				6334	if iNdEx >= l {
				6335	return io.ErrUnexpectedEOF
				6336	}
				6337	b := dAtA[iNdEx]
				6338	iNdEx++
				6339	v \|= (int(b) & 0x7F) << shift
				6340	if b < 0x80 {
				6341	break
				6342	}
				6343	}
				6344	m.Watch = bool(v != 0)
				6345	case 4:
				6346	if wireType != 2 {
				6347	return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
				6348	}
				6349	var stringLen uint64
				6350	for shift := uint(0); ; shift += 7 {
				6351	if shift >= 64 {
				6352	return ErrIntOverflowGenerated
				6353	}
				6354	if iNdEx >= l {
				6355	return io.ErrUnexpectedEOF
				6356	}
				6357	b := dAtA[iNdEx]
				6358	iNdEx++
				6359	stringLen \|= (uint64(b) & 0x7F) << shift
				6360	if b < 0x80 {
				6361	break
				6362	}
				6363	}
				6364	intStringLen := int(stringLen)
				6365	if intStringLen < 0 {
				6366	return ErrInvalidLengthGenerated
				6367	}
				6368	postIndex := iNdEx + intStringLen
				6369	if postIndex > l {
				6370	return io.ErrUnexpectedEOF
				6371	}
				6372	m.ResourceVersion = string(dAtA[iNdEx:postIndex])
				6373	iNdEx = postIndex
				6374	case 5:
				6375	if wireType != 0 {
				6376	return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
				6377	}
				6378	var v int64
				6379	for shift := uint(0); ; shift += 7 {
				6380	if shift >= 64 {
				6381	return ErrIntOverflowGenerated
				6382	}
				6383	if iNdEx >= l {
				6384	return io.ErrUnexpectedEOF
				6385	}
				6386	b := dAtA[iNdEx]
				6387	iNdEx++
				6388	v \|= (int64(b) & 0x7F) << shift
				6389	if b < 0x80 {
				6390	break
				6391	}
				6392	}
				6393	m.TimeoutSeconds = &v
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	6394	case 7:
				6395	if wireType != 0 {
				6396	return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
				6397	}
				6398	m.Limit = 0
				6399	for shift := uint(0); ; shift += 7 {
				6400	if shift >= 64 {
				6401	return ErrIntOverflowGenerated
				6402	}
				6403	if iNdEx >= l {
				6404	return io.ErrUnexpectedEOF
				6405	}
				6406	b := dAtA[iNdEx]
				6407	iNdEx++
				6408	m.Limit \|= (int64(b) & 0x7F) << shift
				6409	if b < 0x80 {
				6410	break
				6411	}
				6412	}
				6413	case 8:
				6414	if wireType != 2 {
				6415	return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
				6416	}
				6417	var stringLen uint64
				6418	for shift := uint(0); ; shift += 7 {
				6419	if shift >= 64 {
				6420	return ErrIntOverflowGenerated
				6421	}
				6422	if iNdEx >= l {
				6423	return io.ErrUnexpectedEOF
				6424	}
				6425	b := dAtA[iNdEx]
				6426	iNdEx++
				6427	stringLen \|= (uint64(b) & 0x7F) << shift
				6428	if b < 0x80 {
				6429	break
				6430	}
				6431	}
				6432	intStringLen := int(stringLen)
				6433	if intStringLen < 0 {
				6434	return ErrInvalidLengthGenerated
				6435	}
				6436	postIndex := iNdEx + intStringLen
				6437	if postIndex > l {
				6438	return io.ErrUnexpectedEOF
				6439	}
				6440	m.Continue = string(dAtA[iNdEx:postIndex])
				6441	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	6442	case 9:
				6443	if wireType != 0 {
				6444	return fmt.Errorf("proto: wrong wireType = %d for field AllowWatchBookmarks", wireType)
				6445	}
				6446	var v int
				6447	for shift := uint(0); ; shift += 7 {
				6448	if shift >= 64 {
				6449	return ErrIntOverflowGenerated
				6450	}
				6451	if iNdEx >= l {
				6452	return io.ErrUnexpectedEOF
				6453	}
				6454	b := dAtA[iNdEx]
				6455	iNdEx++
				6456	v \|= (int(b) & 0x7F) << shift
				6457	if b < 0x80 {
				6458	break
				6459	}
				6460	}
				6461	m.AllowWatchBookmarks = bool(v != 0)
				6462	default:
				6463	iNdEx = preIndex
				6464	skippy, err := skipGenerated(dAtA[iNdEx:])
				6465	if err != nil {
				6466	return err
				6467	}
				6468	if skippy < 0 {
				6469	return ErrInvalidLengthGenerated
				6470	}
				6471	if (iNdEx + skippy) > l {
				6472	return io.ErrUnexpectedEOF
				6473	}
				6474	iNdEx += skippy
				6475	}
				6476	}
				6477
				6478	if iNdEx > l {
				6479	return io.ErrUnexpectedEOF
				6480	}
				6481	return nil
				6482	}
				6483	func (m *ManagedFieldsEntry) Unmarshal(dAtA []byte) error {
				6484	l := len(dAtA)
				6485	iNdEx := 0
				6486	for iNdEx < l {
				6487	preIndex := iNdEx
				6488	var wire uint64
				6489	for shift := uint(0); ; shift += 7 {
				6490	if shift >= 64 {
				6491	return ErrIntOverflowGenerated
				6492	}
				6493	if iNdEx >= l {
				6494	return io.ErrUnexpectedEOF
				6495	}
				6496	b := dAtA[iNdEx]
				6497	iNdEx++
				6498	wire \|= (uint64(b) & 0x7F) << shift
				6499	if b < 0x80 {
				6500	break
				6501	}
				6502	}
				6503	fieldNum := int32(wire >> 3)
				6504	wireType := int(wire & 0x7)
				6505	if wireType == 4 {
				6506	return fmt.Errorf("proto: ManagedFieldsEntry: wiretype end group for non-group")
				6507	}
				6508	if fieldNum <= 0 {
				6509	return fmt.Errorf("proto: ManagedFieldsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
				6510	}
				6511	switch fieldNum {
				6512	case 1:
				6513	if wireType != 2 {
				6514	return fmt.Errorf("proto: wrong wireType = %d for field Manager", wireType)
				6515	}
				6516	var stringLen uint64
				6517	for shift := uint(0); ; shift += 7 {
				6518	if shift >= 64 {
				6519	return ErrIntOverflowGenerated
				6520	}
				6521	if iNdEx >= l {
				6522	return io.ErrUnexpectedEOF
				6523	}
				6524	b := dAtA[iNdEx]
				6525	iNdEx++
				6526	stringLen \|= (uint64(b) & 0x7F) << shift
				6527	if b < 0x80 {
				6528	break
				6529	}
				6530	}
				6531	intStringLen := int(stringLen)
				6532	if intStringLen < 0 {
				6533	return ErrInvalidLengthGenerated
				6534	}
				6535	postIndex := iNdEx + intStringLen
				6536	if postIndex > l {
				6537	return io.ErrUnexpectedEOF
				6538	}
				6539	m.Manager = string(dAtA[iNdEx:postIndex])
				6540	iNdEx = postIndex
				6541	case 2:
				6542	if wireType != 2 {
				6543	return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
				6544	}
				6545	var stringLen uint64
				6546	for shift := uint(0); ; shift += 7 {
				6547	if shift >= 64 {
				6548	return ErrIntOverflowGenerated
				6549	}
				6550	if iNdEx >= l {
				6551	return io.ErrUnexpectedEOF
				6552	}
				6553	b := dAtA[iNdEx]
				6554	iNdEx++
				6555	stringLen \|= (uint64(b) & 0x7F) << shift
				6556	if b < 0x80 {
				6557	break
				6558	}
				6559	}
				6560	intStringLen := int(stringLen)
				6561	if intStringLen < 0 {
				6562	return ErrInvalidLengthGenerated
				6563	}
				6564	postIndex := iNdEx + intStringLen
				6565	if postIndex > l {
				6566	return io.ErrUnexpectedEOF
				6567	}
				6568	m.Operation = ManagedFieldsOperationType(dAtA[iNdEx:postIndex])
				6569	iNdEx = postIndex
				6570	case 3:
				6571	if wireType != 2 {
				6572	return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
				6573	}
				6574	var stringLen uint64
				6575	for shift := uint(0); ; shift += 7 {
				6576	if shift >= 64 {
				6577	return ErrIntOverflowGenerated
				6578	}
				6579	if iNdEx >= l {
				6580	return io.ErrUnexpectedEOF
				6581	}
				6582	b := dAtA[iNdEx]
				6583	iNdEx++
				6584	stringLen \|= (uint64(b) & 0x7F) << shift
				6585	if b < 0x80 {
				6586	break
				6587	}
				6588	}
				6589	intStringLen := int(stringLen)
				6590	if intStringLen < 0 {
				6591	return ErrInvalidLengthGenerated
				6592	}
				6593	postIndex := iNdEx + intStringLen
				6594	if postIndex > l {
				6595	return io.ErrUnexpectedEOF
				6596	}
				6597	m.APIVersion = string(dAtA[iNdEx:postIndex])
				6598	iNdEx = postIndex
				6599	case 4:
				6600	if wireType != 2 {
				6601	return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
				6602	}
				6603	var msglen int
				6604	for shift := uint(0); ; shift += 7 {
				6605	if shift >= 64 {
				6606	return ErrIntOverflowGenerated
				6607	}
				6608	if iNdEx >= l {
				6609	return io.ErrUnexpectedEOF
				6610	}
				6611	b := dAtA[iNdEx]
				6612	iNdEx++
				6613	msglen \|= (int(b) & 0x7F) << shift
				6614	if b < 0x80 {
				6615	break
				6616	}
				6617	}
				6618	if msglen < 0 {
				6619	return ErrInvalidLengthGenerated
				6620	}
				6621	postIndex := iNdEx + msglen
				6622	if postIndex > l {
				6623	return io.ErrUnexpectedEOF
				6624	}
				6625	if m.Time == nil {
				6626	m.Time = &Time{}
				6627	}
				6628	if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6629	return err
				6630	}
				6631	iNdEx = postIndex
				6632	case 5:
				6633	if wireType != 2 {
				6634	return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
				6635	}
				6636	var msglen int
				6637	for shift := uint(0); ; shift += 7 {
				6638	if shift >= 64 {
				6639	return ErrIntOverflowGenerated
				6640	}
				6641	if iNdEx >= l {
				6642	return io.ErrUnexpectedEOF
				6643	}
				6644	b := dAtA[iNdEx]
				6645	iNdEx++
				6646	msglen \|= (int(b) & 0x7F) << shift
				6647	if b < 0x80 {
				6648	break
				6649	}
				6650	}
				6651	if msglen < 0 {
				6652	return ErrInvalidLengthGenerated
				6653	}
				6654	postIndex := iNdEx + msglen
				6655	if postIndex > l {
				6656	return io.ErrUnexpectedEOF
				6657	}
				6658	if m.Fields == nil {
				6659	m.Fields = &Fields{}
				6660	}
				6661	if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6662	return err
				6663	}
				6664	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	6665	default:
				6666	iNdEx = preIndex
				6667	skippy, err := skipGenerated(dAtA[iNdEx:])
				6668	if err != nil {
				6669	return err
				6670	}
				6671	if skippy < 0 {
				6672	return ErrInvalidLengthGenerated
				6673	}
				6674	if (iNdEx + skippy) > l {
				6675	return io.ErrUnexpectedEOF
				6676	}
				6677	iNdEx += skippy
				6678	}
				6679	}
				6680
				6681	if iNdEx > l {
				6682	return io.ErrUnexpectedEOF
				6683	}
				6684	return nil
				6685	}
				6686	func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
				6687	l := len(dAtA)
				6688	iNdEx := 0
				6689	for iNdEx < l {
				6690	preIndex := iNdEx
				6691	var wire uint64
				6692	for shift := uint(0); ; shift += 7 {
				6693	if shift >= 64 {
				6694	return ErrIntOverflowGenerated
				6695	}
				6696	if iNdEx >= l {
				6697	return io.ErrUnexpectedEOF
				6698	}
				6699	b := dAtA[iNdEx]
				6700	iNdEx++
				6701	wire \|= (uint64(b) & 0x7F) << shift
				6702	if b < 0x80 {
				6703	break
				6704	}
				6705	}
				6706	fieldNum := int32(wire >> 3)
				6707	wireType := int(wire & 0x7)
				6708	if wireType == 4 {
				6709	return fmt.Errorf("proto: ObjectMeta: wiretype end group for non-group")
				6710	}
				6711	if fieldNum <= 0 {
				6712	return fmt.Errorf("proto: ObjectMeta: illegal tag %d (wire type %d)", fieldNum, wire)
				6713	}
				6714	switch fieldNum {
				6715	case 1:
				6716	if wireType != 2 {
				6717	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				6718	}
				6719	var stringLen uint64
				6720	for shift := uint(0); ; shift += 7 {
				6721	if shift >= 64 {
				6722	return ErrIntOverflowGenerated
				6723	}
				6724	if iNdEx >= l {
				6725	return io.ErrUnexpectedEOF
				6726	}
				6727	b := dAtA[iNdEx]
				6728	iNdEx++
				6729	stringLen \|= (uint64(b) & 0x7F) << shift
				6730	if b < 0x80 {
				6731	break
				6732	}
				6733	}
				6734	intStringLen := int(stringLen)
				6735	if intStringLen < 0 {
				6736	return ErrInvalidLengthGenerated
				6737	}
				6738	postIndex := iNdEx + intStringLen
				6739	if postIndex > l {
				6740	return io.ErrUnexpectedEOF
				6741	}
				6742	m.Name = string(dAtA[iNdEx:postIndex])
				6743	iNdEx = postIndex
				6744	case 2:
				6745	if wireType != 2 {
				6746	return fmt.Errorf("proto: wrong wireType = %d for field GenerateName", wireType)
				6747	}
				6748	var stringLen uint64
				6749	for shift := uint(0); ; shift += 7 {
				6750	if shift >= 64 {
				6751	return ErrIntOverflowGenerated
				6752	}
				6753	if iNdEx >= l {
				6754	return io.ErrUnexpectedEOF
				6755	}
				6756	b := dAtA[iNdEx]
				6757	iNdEx++
				6758	stringLen \|= (uint64(b) & 0x7F) << shift
				6759	if b < 0x80 {
				6760	break
				6761	}
				6762	}
				6763	intStringLen := int(stringLen)
				6764	if intStringLen < 0 {
				6765	return ErrInvalidLengthGenerated
				6766	}
				6767	postIndex := iNdEx + intStringLen
				6768	if postIndex > l {
				6769	return io.ErrUnexpectedEOF
				6770	}
				6771	m.GenerateName = string(dAtA[iNdEx:postIndex])
				6772	iNdEx = postIndex
				6773	case 3:
				6774	if wireType != 2 {
				6775	return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
				6776	}
				6777	var stringLen uint64
				6778	for shift := uint(0); ; shift += 7 {
				6779	if shift >= 64 {
				6780	return ErrIntOverflowGenerated
				6781	}
				6782	if iNdEx >= l {
				6783	return io.ErrUnexpectedEOF
				6784	}
				6785	b := dAtA[iNdEx]
				6786	iNdEx++
				6787	stringLen \|= (uint64(b) & 0x7F) << shift
				6788	if b < 0x80 {
				6789	break
				6790	}
				6791	}
				6792	intStringLen := int(stringLen)
				6793	if intStringLen < 0 {
				6794	return ErrInvalidLengthGenerated
				6795	}
				6796	postIndex := iNdEx + intStringLen
				6797	if postIndex > l {
				6798	return io.ErrUnexpectedEOF
				6799	}
				6800	m.Namespace = string(dAtA[iNdEx:postIndex])
				6801	iNdEx = postIndex
				6802	case 4:
				6803	if wireType != 2 {
				6804	return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
				6805	}
				6806	var stringLen uint64
				6807	for shift := uint(0); ; shift += 7 {
				6808	if shift >= 64 {
				6809	return ErrIntOverflowGenerated
				6810	}
				6811	if iNdEx >= l {
				6812	return io.ErrUnexpectedEOF
				6813	}
				6814	b := dAtA[iNdEx]
				6815	iNdEx++
				6816	stringLen \|= (uint64(b) & 0x7F) << shift
				6817	if b < 0x80 {
				6818	break
				6819	}
				6820	}
				6821	intStringLen := int(stringLen)
				6822	if intStringLen < 0 {
				6823	return ErrInvalidLengthGenerated
				6824	}
				6825	postIndex := iNdEx + intStringLen
				6826	if postIndex > l {
				6827	return io.ErrUnexpectedEOF
				6828	}
				6829	m.SelfLink = string(dAtA[iNdEx:postIndex])
				6830	iNdEx = postIndex
				6831	case 5:
				6832	if wireType != 2 {
				6833	return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
				6834	}
				6835	var stringLen uint64
				6836	for shift := uint(0); ; shift += 7 {
				6837	if shift >= 64 {
				6838	return ErrIntOverflowGenerated
				6839	}
				6840	if iNdEx >= l {
				6841	return io.ErrUnexpectedEOF
				6842	}
				6843	b := dAtA[iNdEx]
				6844	iNdEx++
				6845	stringLen \|= (uint64(b) & 0x7F) << shift
				6846	if b < 0x80 {
				6847	break
				6848	}
				6849	}
				6850	intStringLen := int(stringLen)
				6851	if intStringLen < 0 {
				6852	return ErrInvalidLengthGenerated
				6853	}
				6854	postIndex := iNdEx + intStringLen
				6855	if postIndex > l {
				6856	return io.ErrUnexpectedEOF
				6857	}
				6858	m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
				6859	iNdEx = postIndex
				6860	case 6:
				6861	if wireType != 2 {
				6862	return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
				6863	}
				6864	var stringLen uint64
				6865	for shift := uint(0); ; shift += 7 {
				6866	if shift >= 64 {
				6867	return ErrIntOverflowGenerated
				6868	}
				6869	if iNdEx >= l {
				6870	return io.ErrUnexpectedEOF
				6871	}
				6872	b := dAtA[iNdEx]
				6873	iNdEx++
				6874	stringLen \|= (uint64(b) & 0x7F) << shift
				6875	if b < 0x80 {
				6876	break
				6877	}
				6878	}
				6879	intStringLen := int(stringLen)
				6880	if intStringLen < 0 {
				6881	return ErrInvalidLengthGenerated
				6882	}
				6883	postIndex := iNdEx + intStringLen
				6884	if postIndex > l {
				6885	return io.ErrUnexpectedEOF
				6886	}
				6887	m.ResourceVersion = string(dAtA[iNdEx:postIndex])
				6888	iNdEx = postIndex
				6889	case 7:
				6890	if wireType != 0 {
				6891	return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
				6892	}
				6893	m.Generation = 0
				6894	for shift := uint(0); ; shift += 7 {
				6895	if shift >= 64 {
				6896	return ErrIntOverflowGenerated
				6897	}
				6898	if iNdEx >= l {
				6899	return io.ErrUnexpectedEOF
				6900	}
				6901	b := dAtA[iNdEx]
				6902	iNdEx++
				6903	m.Generation \|= (int64(b) & 0x7F) << shift
				6904	if b < 0x80 {
				6905	break
				6906	}
				6907	}
				6908	case 8:
				6909	if wireType != 2 {
				6910	return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestamp", wireType)
				6911	}
				6912	var msglen int
				6913	for shift := uint(0); ; shift += 7 {
				6914	if shift >= 64 {
				6915	return ErrIntOverflowGenerated
				6916	}
				6917	if iNdEx >= l {
				6918	return io.ErrUnexpectedEOF
				6919	}
				6920	b := dAtA[iNdEx]
				6921	iNdEx++
				6922	msglen \|= (int(b) & 0x7F) << shift
				6923	if b < 0x80 {
				6924	break
				6925	}
				6926	}
				6927	if msglen < 0 {
				6928	return ErrInvalidLengthGenerated
				6929	}
				6930	postIndex := iNdEx + msglen
				6931	if postIndex > l {
				6932	return io.ErrUnexpectedEOF
				6933	}
				6934	if err := m.CreationTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6935	return err
				6936	}
				6937	iNdEx = postIndex
				6938	case 9:
				6939	if wireType != 2 {
				6940	return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestamp", wireType)
				6941	}
				6942	var msglen int
				6943	for shift := uint(0); ; shift += 7 {
				6944	if shift >= 64 {
				6945	return ErrIntOverflowGenerated
				6946	}
				6947	if iNdEx >= l {
				6948	return io.ErrUnexpectedEOF
				6949	}
				6950	b := dAtA[iNdEx]
				6951	iNdEx++
				6952	msglen \|= (int(b) & 0x7F) << shift
				6953	if b < 0x80 {
				6954	break
				6955	}
				6956	}
				6957	if msglen < 0 {
				6958	return ErrInvalidLengthGenerated
				6959	}
				6960	postIndex := iNdEx + msglen
				6961	if postIndex > l {
				6962	return io.ErrUnexpectedEOF
				6963	}
				6964	if m.DeletionTimestamp == nil {
				6965	m.DeletionTimestamp = &Time{}
				6966	}
				6967	if err := m.DeletionTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				6968	return err
				6969	}
				6970	iNdEx = postIndex
				6971	case 10:
				6972	if wireType != 0 {
				6973	return fmt.Errorf("proto: wrong wireType = %d for field DeletionGracePeriodSeconds", wireType)
				6974	}
				6975	var v int64
				6976	for shift := uint(0); ; shift += 7 {
				6977	if shift >= 64 {
				6978	return ErrIntOverflowGenerated
				6979	}
				6980	if iNdEx >= l {
				6981	return io.ErrUnexpectedEOF
				6982	}
				6983	b := dAtA[iNdEx]
				6984	iNdEx++
				6985	v \|= (int64(b) & 0x7F) << shift
				6986	if b < 0x80 {
				6987	break
				6988	}
				6989	}
				6990	m.DeletionGracePeriodSeconds = &v
				6991	case 11:
				6992	if wireType != 2 {
				6993	return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
				6994	}
				6995	var msglen int
				6996	for shift := uint(0); ; shift += 7 {
				6997	if shift >= 64 {
				6998	return ErrIntOverflowGenerated
				6999	}
				7000	if iNdEx >= l {
				7001	return io.ErrUnexpectedEOF
				7002	}
				7003	b := dAtA[iNdEx]
				7004	iNdEx++
				7005	msglen \|= (int(b) & 0x7F) << shift
				7006	if b < 0x80 {
				7007	break
				7008	}
				7009	}
				7010	if msglen < 0 {
				7011	return ErrInvalidLengthGenerated
				7012	}
				7013	postIndex := iNdEx + msglen
				7014	if postIndex > l {
				7015	return io.ErrUnexpectedEOF
				7016	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7017	if m.Labels == nil {
				7018	m.Labels = make(map[string]string)
				7019	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7020	var mapkey string
				7021	var mapvalue string
				7022	for iNdEx < postIndex {
				7023	entryPreIndex := iNdEx
				7024	var wire uint64
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7025	for shift := uint(0); ; shift += 7 {
				7026	if shift >= 64 {
				7027	return ErrIntOverflowGenerated
				7028	}
				7029	if iNdEx >= l {
				7030	return io.ErrUnexpectedEOF
				7031	}
				7032	b := dAtA[iNdEx]
				7033	iNdEx++
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7034	wire \|= (uint64(b) & 0x7F) << shift
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7035	if b < 0x80 {
				7036	break
				7037	}
				7038	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7039	fieldNum := int32(wire >> 3)
				7040	if fieldNum == 1 {
				7041	var stringLenmapkey uint64
				7042	for shift := uint(0); ; shift += 7 {
				7043	if shift >= 64 {
				7044	return ErrIntOverflowGenerated
				7045	}
				7046	if iNdEx >= l {
				7047	return io.ErrUnexpectedEOF
				7048	}
				7049	b := dAtA[iNdEx]
				7050	iNdEx++
				7051	stringLenmapkey \|= (uint64(b) & 0x7F) << shift
				7052	if b < 0x80 {
				7053	break
				7054	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7055	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7056	intStringLenmapkey := int(stringLenmapkey)
				7057	if intStringLenmapkey < 0 {
				7058	return ErrInvalidLengthGenerated
				7059	}
				7060	postStringIndexmapkey := iNdEx + intStringLenmapkey
				7061	if postStringIndexmapkey > l {
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7062	return io.ErrUnexpectedEOF
				7063	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7064	mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
				7065	iNdEx = postStringIndexmapkey
				7066	} else if fieldNum == 2 {
				7067	var stringLenmapvalue uint64
				7068	for shift := uint(0); ; shift += 7 {
				7069	if shift >= 64 {
				7070	return ErrIntOverflowGenerated
				7071	}
				7072	if iNdEx >= l {
				7073	return io.ErrUnexpectedEOF
				7074	}
				7075	b := dAtA[iNdEx]
				7076	iNdEx++
				7077	stringLenmapvalue \|= (uint64(b) & 0x7F) << shift
				7078	if b < 0x80 {
				7079	break
				7080	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7081	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7082	intStringLenmapvalue := int(stringLenmapvalue)
				7083	if intStringLenmapvalue < 0 {
				7084	return ErrInvalidLengthGenerated
				7085	}
				7086	postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				7087	if postStringIndexmapvalue > l {
				7088	return io.ErrUnexpectedEOF
				7089	}
				7090	mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
				7091	iNdEx = postStringIndexmapvalue
				7092	} else {
				7093	iNdEx = entryPreIndex
				7094	skippy, err := skipGenerated(dAtA[iNdEx:])
				7095	if err != nil {
				7096	return err
				7097	}
				7098	if skippy < 0 {
				7099	return ErrInvalidLengthGenerated
				7100	}
				7101	if (iNdEx + skippy) > postIndex {
				7102	return io.ErrUnexpectedEOF
				7103	}
				7104	iNdEx += skippy
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7105	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7106	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7107	m.Labels[mapkey] = mapvalue
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7108	iNdEx = postIndex
				7109	case 12:
				7110	if wireType != 2 {
				7111	return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
				7112	}
				7113	var msglen int
				7114	for shift := uint(0); ; shift += 7 {
				7115	if shift >= 64 {
				7116	return ErrIntOverflowGenerated
				7117	}
				7118	if iNdEx >= l {
				7119	return io.ErrUnexpectedEOF
				7120	}
				7121	b := dAtA[iNdEx]
				7122	iNdEx++
				7123	msglen \|= (int(b) & 0x7F) << shift
				7124	if b < 0x80 {
				7125	break
				7126	}
				7127	}
				7128	if msglen < 0 {
				7129	return ErrInvalidLengthGenerated
				7130	}
				7131	postIndex := iNdEx + msglen
				7132	if postIndex > l {
				7133	return io.ErrUnexpectedEOF
				7134	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7135	if m.Annotations == nil {
				7136	m.Annotations = make(map[string]string)
				7137	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7138	var mapkey string
				7139	var mapvalue string
				7140	for iNdEx < postIndex {
				7141	entryPreIndex := iNdEx
				7142	var wire uint64
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7143	for shift := uint(0); ; shift += 7 {
				7144	if shift >= 64 {
				7145	return ErrIntOverflowGenerated
				7146	}
				7147	if iNdEx >= l {
				7148	return io.ErrUnexpectedEOF
				7149	}
				7150	b := dAtA[iNdEx]
				7151	iNdEx++
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7152	wire \|= (uint64(b) & 0x7F) << shift
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7153	if b < 0x80 {
				7154	break
				7155	}
				7156	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7157	fieldNum := int32(wire >> 3)
				7158	if fieldNum == 1 {
				7159	var stringLenmapkey uint64
				7160	for shift := uint(0); ; shift += 7 {
				7161	if shift >= 64 {
				7162	return ErrIntOverflowGenerated
				7163	}
				7164	if iNdEx >= l {
				7165	return io.ErrUnexpectedEOF
				7166	}
				7167	b := dAtA[iNdEx]
				7168	iNdEx++
				7169	stringLenmapkey \|= (uint64(b) & 0x7F) << shift
				7170	if b < 0x80 {
				7171	break
				7172	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7173	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7174	intStringLenmapkey := int(stringLenmapkey)
				7175	if intStringLenmapkey < 0 {
				7176	return ErrInvalidLengthGenerated
				7177	}
				7178	postStringIndexmapkey := iNdEx + intStringLenmapkey
				7179	if postStringIndexmapkey > l {
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7180	return io.ErrUnexpectedEOF
				7181	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7182	mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
				7183	iNdEx = postStringIndexmapkey
				7184	} else if fieldNum == 2 {
				7185	var stringLenmapvalue uint64
				7186	for shift := uint(0); ; shift += 7 {
				7187	if shift >= 64 {
				7188	return ErrIntOverflowGenerated
				7189	}
				7190	if iNdEx >= l {
				7191	return io.ErrUnexpectedEOF
				7192	}
				7193	b := dAtA[iNdEx]
				7194	iNdEx++
				7195	stringLenmapvalue \|= (uint64(b) & 0x7F) << shift
				7196	if b < 0x80 {
				7197	break
				7198	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7199	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7200	intStringLenmapvalue := int(stringLenmapvalue)
				7201	if intStringLenmapvalue < 0 {
				7202	return ErrInvalidLengthGenerated
				7203	}
				7204	postStringIndexmapvalue := iNdEx + intStringLenmapvalue
				7205	if postStringIndexmapvalue > l {
				7206	return io.ErrUnexpectedEOF
				7207	}
				7208	mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
				7209	iNdEx = postStringIndexmapvalue
				7210	} else {
				7211	iNdEx = entryPreIndex
				7212	skippy, err := skipGenerated(dAtA[iNdEx:])
				7213	if err != nil {
				7214	return err
				7215	}
				7216	if skippy < 0 {
				7217	return ErrInvalidLengthGenerated
				7218	}
				7219	if (iNdEx + skippy) > postIndex {
				7220	return io.ErrUnexpectedEOF
				7221	}
				7222	iNdEx += skippy
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7223	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7224	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7225	m.Annotations[mapkey] = mapvalue
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7226	iNdEx = postIndex
				7227	case 13:
				7228	if wireType != 2 {
				7229	return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
				7230	}
				7231	var msglen int
				7232	for shift := uint(0); ; shift += 7 {
				7233	if shift >= 64 {
				7234	return ErrIntOverflowGenerated
				7235	}
				7236	if iNdEx >= l {
				7237	return io.ErrUnexpectedEOF
				7238	}
				7239	b := dAtA[iNdEx]
				7240	iNdEx++
				7241	msglen \|= (int(b) & 0x7F) << shift
				7242	if b < 0x80 {
				7243	break
				7244	}
				7245	}
				7246	if msglen < 0 {
				7247	return ErrInvalidLengthGenerated
				7248	}
				7249	postIndex := iNdEx + msglen
				7250	if postIndex > l {
				7251	return io.ErrUnexpectedEOF
				7252	}
				7253	m.OwnerReferences = append(m.OwnerReferences, OwnerReference{})
				7254	if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7255	return err
				7256	}
				7257	iNdEx = postIndex
				7258	case 14:
				7259	if wireType != 2 {
				7260	return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType)
				7261	}
				7262	var stringLen uint64
				7263	for shift := uint(0); ; shift += 7 {
				7264	if shift >= 64 {
				7265	return ErrIntOverflowGenerated
				7266	}
				7267	if iNdEx >= l {
				7268	return io.ErrUnexpectedEOF
				7269	}
				7270	b := dAtA[iNdEx]
				7271	iNdEx++
				7272	stringLen \|= (uint64(b) & 0x7F) << shift
				7273	if b < 0x80 {
				7274	break
				7275	}
				7276	}
				7277	intStringLen := int(stringLen)
				7278	if intStringLen < 0 {
				7279	return ErrInvalidLengthGenerated
				7280	}
				7281	postIndex := iNdEx + intStringLen
				7282	if postIndex > l {
				7283	return io.ErrUnexpectedEOF
				7284	}
				7285	m.Finalizers = append(m.Finalizers, string(dAtA[iNdEx:postIndex]))
				7286	iNdEx = postIndex
				7287	case 15:
				7288	if wireType != 2 {
				7289	return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
				7290	}
				7291	var stringLen uint64
				7292	for shift := uint(0); ; shift += 7 {
				7293	if shift >= 64 {
				7294	return ErrIntOverflowGenerated
				7295	}
				7296	if iNdEx >= l {
				7297	return io.ErrUnexpectedEOF
				7298	}
				7299	b := dAtA[iNdEx]
				7300	iNdEx++
				7301	stringLen \|= (uint64(b) & 0x7F) << shift
				7302	if b < 0x80 {
				7303	break
				7304	}
				7305	}
				7306	intStringLen := int(stringLen)
				7307	if intStringLen < 0 {
				7308	return ErrInvalidLengthGenerated
				7309	}
				7310	postIndex := iNdEx + intStringLen
				7311	if postIndex > l {
				7312	return io.ErrUnexpectedEOF
				7313	}
				7314	m.ClusterName = string(dAtA[iNdEx:postIndex])
				7315	iNdEx = postIndex
				7316	case 16:
				7317	if wireType != 2 {
				7318	return fmt.Errorf("proto: wrong wireType = %d for field Initializers", wireType)
				7319	}
				7320	var msglen int
				7321	for shift := uint(0); ; shift += 7 {
				7322	if shift >= 64 {
				7323	return ErrIntOverflowGenerated
				7324	}
				7325	if iNdEx >= l {
				7326	return io.ErrUnexpectedEOF
				7327	}
				7328	b := dAtA[iNdEx]
				7329	iNdEx++
				7330	msglen \|= (int(b) & 0x7F) << shift
				7331	if b < 0x80 {
				7332	break
				7333	}
				7334	}
				7335	if msglen < 0 {
				7336	return ErrInvalidLengthGenerated
				7337	}
				7338	postIndex := iNdEx + msglen
				7339	if postIndex > l {
				7340	return io.ErrUnexpectedEOF
				7341	}
				7342	if m.Initializers == nil {
				7343	m.Initializers = &Initializers{}
				7344	}
				7345	if err := m.Initializers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7346	return err
				7347	}
				7348	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7349	case 17:
				7350	if wireType != 2 {
				7351	return fmt.Errorf("proto: wrong wireType = %d for field ManagedFields", wireType)
				7352	}
				7353	var msglen int
				7354	for shift := uint(0); ; shift += 7 {
				7355	if shift >= 64 {
				7356	return ErrIntOverflowGenerated
				7357	}
				7358	if iNdEx >= l {
				7359	return io.ErrUnexpectedEOF
				7360	}
				7361	b := dAtA[iNdEx]
				7362	iNdEx++
				7363	msglen \|= (int(b) & 0x7F) << shift
				7364	if b < 0x80 {
				7365	break
				7366	}
				7367	}
				7368	if msglen < 0 {
				7369	return ErrInvalidLengthGenerated
				7370	}
				7371	postIndex := iNdEx + msglen
				7372	if postIndex > l {
				7373	return io.ErrUnexpectedEOF
				7374	}
				7375	m.ManagedFields = append(m.ManagedFields, ManagedFieldsEntry{})
				7376	if err := m.ManagedFields[len(m.ManagedFields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7377	return err
				7378	}
				7379	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7380	default:
				7381	iNdEx = preIndex
				7382	skippy, err := skipGenerated(dAtA[iNdEx:])
				7383	if err != nil {
				7384	return err
				7385	}
				7386	if skippy < 0 {
				7387	return ErrInvalidLengthGenerated
				7388	}
				7389	if (iNdEx + skippy) > l {
				7390	return io.ErrUnexpectedEOF
				7391	}
				7392	iNdEx += skippy
				7393	}
				7394	}
				7395
				7396	if iNdEx > l {
				7397	return io.ErrUnexpectedEOF
				7398	}
				7399	return nil
				7400	}
				7401	func (m *OwnerReference) Unmarshal(dAtA []byte) error {
				7402	l := len(dAtA)
				7403	iNdEx := 0
				7404	for iNdEx < l {
				7405	preIndex := iNdEx
				7406	var wire uint64
				7407	for shift := uint(0); ; shift += 7 {
				7408	if shift >= 64 {
				7409	return ErrIntOverflowGenerated
				7410	}
				7411	if iNdEx >= l {
				7412	return io.ErrUnexpectedEOF
				7413	}
				7414	b := dAtA[iNdEx]
				7415	iNdEx++
				7416	wire \|= (uint64(b) & 0x7F) << shift
				7417	if b < 0x80 {
				7418	break
				7419	}
				7420	}
				7421	fieldNum := int32(wire >> 3)
				7422	wireType := int(wire & 0x7)
				7423	if wireType == 4 {
				7424	return fmt.Errorf("proto: OwnerReference: wiretype end group for non-group")
				7425	}
				7426	if fieldNum <= 0 {
				7427	return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire)
				7428	}
				7429	switch fieldNum {
				7430	case 1:
				7431	if wireType != 2 {
				7432	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				7433	}
				7434	var stringLen uint64
				7435	for shift := uint(0); ; shift += 7 {
				7436	if shift >= 64 {
				7437	return ErrIntOverflowGenerated
				7438	}
				7439	if iNdEx >= l {
				7440	return io.ErrUnexpectedEOF
				7441	}
				7442	b := dAtA[iNdEx]
				7443	iNdEx++
				7444	stringLen \|= (uint64(b) & 0x7F) << shift
				7445	if b < 0x80 {
				7446	break
				7447	}
				7448	}
				7449	intStringLen := int(stringLen)
				7450	if intStringLen < 0 {
				7451	return ErrInvalidLengthGenerated
				7452	}
				7453	postIndex := iNdEx + intStringLen
				7454	if postIndex > l {
				7455	return io.ErrUnexpectedEOF
				7456	}
				7457	m.Kind = string(dAtA[iNdEx:postIndex])
				7458	iNdEx = postIndex
				7459	case 3:
				7460	if wireType != 2 {
				7461	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				7462	}
				7463	var stringLen uint64
				7464	for shift := uint(0); ; shift += 7 {
				7465	if shift >= 64 {
				7466	return ErrIntOverflowGenerated
				7467	}
				7468	if iNdEx >= l {
				7469	return io.ErrUnexpectedEOF
				7470	}
				7471	b := dAtA[iNdEx]
				7472	iNdEx++
				7473	stringLen \|= (uint64(b) & 0x7F) << shift
				7474	if b < 0x80 {
				7475	break
				7476	}
				7477	}
				7478	intStringLen := int(stringLen)
				7479	if intStringLen < 0 {
				7480	return ErrInvalidLengthGenerated
				7481	}
				7482	postIndex := iNdEx + intStringLen
				7483	if postIndex > l {
				7484	return io.ErrUnexpectedEOF
				7485	}
				7486	m.Name = string(dAtA[iNdEx:postIndex])
				7487	iNdEx = postIndex
				7488	case 4:
				7489	if wireType != 2 {
				7490	return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
				7491	}
				7492	var stringLen uint64
				7493	for shift := uint(0); ; shift += 7 {
				7494	if shift >= 64 {
				7495	return ErrIntOverflowGenerated
				7496	}
				7497	if iNdEx >= l {
				7498	return io.ErrUnexpectedEOF
				7499	}
				7500	b := dAtA[iNdEx]
				7501	iNdEx++
				7502	stringLen \|= (uint64(b) & 0x7F) << shift
				7503	if b < 0x80 {
				7504	break
				7505	}
				7506	}
				7507	intStringLen := int(stringLen)
				7508	if intStringLen < 0 {
				7509	return ErrInvalidLengthGenerated
				7510	}
				7511	postIndex := iNdEx + intStringLen
				7512	if postIndex > l {
				7513	return io.ErrUnexpectedEOF
				7514	}
				7515	m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
				7516	iNdEx = postIndex
				7517	case 5:
				7518	if wireType != 2 {
				7519	return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
				7520	}
				7521	var stringLen uint64
				7522	for shift := uint(0); ; shift += 7 {
				7523	if shift >= 64 {
				7524	return ErrIntOverflowGenerated
				7525	}
				7526	if iNdEx >= l {
				7527	return io.ErrUnexpectedEOF
				7528	}
				7529	b := dAtA[iNdEx]
				7530	iNdEx++
				7531	stringLen \|= (uint64(b) & 0x7F) << shift
				7532	if b < 0x80 {
				7533	break
				7534	}
				7535	}
				7536	intStringLen := int(stringLen)
				7537	if intStringLen < 0 {
				7538	return ErrInvalidLengthGenerated
				7539	}
				7540	postIndex := iNdEx + intStringLen
				7541	if postIndex > l {
				7542	return io.ErrUnexpectedEOF
				7543	}
				7544	m.APIVersion = string(dAtA[iNdEx:postIndex])
				7545	iNdEx = postIndex
				7546	case 6:
				7547	if wireType != 0 {
				7548	return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
				7549	}
				7550	var v int
				7551	for shift := uint(0); ; shift += 7 {
				7552	if shift >= 64 {
				7553	return ErrIntOverflowGenerated
				7554	}
				7555	if iNdEx >= l {
				7556	return io.ErrUnexpectedEOF
				7557	}
				7558	b := dAtA[iNdEx]
				7559	iNdEx++
				7560	v \|= (int(b) & 0x7F) << shift
				7561	if b < 0x80 {
				7562	break
				7563	}
				7564	}
				7565	b := bool(v != 0)
				7566	m.Controller = &b
				7567	case 7:
				7568	if wireType != 0 {
				7569	return fmt.Errorf("proto: wrong wireType = %d for field BlockOwnerDeletion", wireType)
				7570	}
				7571	var v int
				7572	for shift := uint(0); ; shift += 7 {
				7573	if shift >= 64 {
				7574	return ErrIntOverflowGenerated
				7575	}
				7576	if iNdEx >= l {
				7577	return io.ErrUnexpectedEOF
				7578	}
				7579	b := dAtA[iNdEx]
				7580	iNdEx++
				7581	v \|= (int(b) & 0x7F) << shift
				7582	if b < 0x80 {
				7583	break
				7584	}
				7585	}
				7586	b := bool(v != 0)
				7587	m.BlockOwnerDeletion = &b
				7588	default:
				7589	iNdEx = preIndex
				7590	skippy, err := skipGenerated(dAtA[iNdEx:])
				7591	if err != nil {
				7592	return err
				7593	}
				7594	if skippy < 0 {
				7595	return ErrInvalidLengthGenerated
				7596	}
				7597	if (iNdEx + skippy) > l {
				7598	return io.ErrUnexpectedEOF
				7599	}
				7600	iNdEx += skippy
				7601	}
				7602	}
				7603
				7604	if iNdEx > l {
				7605	return io.ErrUnexpectedEOF
				7606	}
				7607	return nil
				7608	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7609	func (m *PartialObjectMetadata) Unmarshal(dAtA []byte) error {
				7610	l := len(dAtA)
				7611	iNdEx := 0
				7612	for iNdEx < l {
				7613	preIndex := iNdEx
				7614	var wire uint64
				7615	for shift := uint(0); ; shift += 7 {
				7616	if shift >= 64 {
				7617	return ErrIntOverflowGenerated
				7618	}
				7619	if iNdEx >= l {
				7620	return io.ErrUnexpectedEOF
				7621	}
				7622	b := dAtA[iNdEx]
				7623	iNdEx++
				7624	wire \|= (uint64(b) & 0x7F) << shift
				7625	if b < 0x80 {
				7626	break
				7627	}
				7628	}
				7629	fieldNum := int32(wire >> 3)
				7630	wireType := int(wire & 0x7)
				7631	if wireType == 4 {
				7632	return fmt.Errorf("proto: PartialObjectMetadata: wiretype end group for non-group")
				7633	}
				7634	if fieldNum <= 0 {
				7635	return fmt.Errorf("proto: PartialObjectMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
				7636	}
				7637	switch fieldNum {
				7638	case 1:
				7639	if wireType != 2 {
				7640	return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
				7641	}
				7642	var msglen int
				7643	for shift := uint(0); ; shift += 7 {
				7644	if shift >= 64 {
				7645	return ErrIntOverflowGenerated
				7646	}
				7647	if iNdEx >= l {
				7648	return io.ErrUnexpectedEOF
				7649	}
				7650	b := dAtA[iNdEx]
				7651	iNdEx++
				7652	msglen \|= (int(b) & 0x7F) << shift
				7653	if b < 0x80 {
				7654	break
				7655	}
				7656	}
				7657	if msglen < 0 {
				7658	return ErrInvalidLengthGenerated
				7659	}
				7660	postIndex := iNdEx + msglen
				7661	if postIndex > l {
				7662	return io.ErrUnexpectedEOF
				7663	}
				7664	if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7665	return err
				7666	}
				7667	iNdEx = postIndex
				7668	default:
				7669	iNdEx = preIndex
				7670	skippy, err := skipGenerated(dAtA[iNdEx:])
				7671	if err != nil {
				7672	return err
				7673	}
				7674	if skippy < 0 {
				7675	return ErrInvalidLengthGenerated
				7676	}
				7677	if (iNdEx + skippy) > l {
				7678	return io.ErrUnexpectedEOF
				7679	}
				7680	iNdEx += skippy
				7681	}
				7682	}
				7683
				7684	if iNdEx > l {
				7685	return io.ErrUnexpectedEOF
				7686	}
				7687	return nil
				7688	}
				7689	func (m *PartialObjectMetadataList) Unmarshal(dAtA []byte) error {
				7690	l := len(dAtA)
				7691	iNdEx := 0
				7692	for iNdEx < l {
				7693	preIndex := iNdEx
				7694	var wire uint64
				7695	for shift := uint(0); ; shift += 7 {
				7696	if shift >= 64 {
				7697	return ErrIntOverflowGenerated
				7698	}
				7699	if iNdEx >= l {
				7700	return io.ErrUnexpectedEOF
				7701	}
				7702	b := dAtA[iNdEx]
				7703	iNdEx++
				7704	wire \|= (uint64(b) & 0x7F) << shift
				7705	if b < 0x80 {
				7706	break
				7707	}
				7708	}
				7709	fieldNum := int32(wire >> 3)
				7710	wireType := int(wire & 0x7)
				7711	if wireType == 4 {
				7712	return fmt.Errorf("proto: PartialObjectMetadataList: wiretype end group for non-group")
				7713	}
				7714	if fieldNum <= 0 {
				7715	return fmt.Errorf("proto: PartialObjectMetadataList: illegal tag %d (wire type %d)", fieldNum, wire)
				7716	}
				7717	switch fieldNum {
				7718	case 1:
				7719	if wireType != 2 {
				7720	return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
				7721	}
				7722	var msglen int
				7723	for shift := uint(0); ; shift += 7 {
				7724	if shift >= 64 {
				7725	return ErrIntOverflowGenerated
				7726	}
				7727	if iNdEx >= l {
				7728	return io.ErrUnexpectedEOF
				7729	}
				7730	b := dAtA[iNdEx]
				7731	iNdEx++
				7732	msglen \|= (int(b) & 0x7F) << shift
				7733	if b < 0x80 {
				7734	break
				7735	}
				7736	}
				7737	if msglen < 0 {
				7738	return ErrInvalidLengthGenerated
				7739	}
				7740	postIndex := iNdEx + msglen
				7741	if postIndex > l {
				7742	return io.ErrUnexpectedEOF
				7743	}
				7744	if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7745	return err
				7746	}
				7747	iNdEx = postIndex
				7748	case 2:
				7749	if wireType != 2 {
				7750	return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
				7751	}
				7752	var msglen int
				7753	for shift := uint(0); ; shift += 7 {
				7754	if shift >= 64 {
				7755	return ErrIntOverflowGenerated
				7756	}
				7757	if iNdEx >= l {
				7758	return io.ErrUnexpectedEOF
				7759	}
				7760	b := dAtA[iNdEx]
				7761	iNdEx++
				7762	msglen \|= (int(b) & 0x7F) << shift
				7763	if b < 0x80 {
				7764	break
				7765	}
				7766	}
				7767	if msglen < 0 {
				7768	return ErrInvalidLengthGenerated
				7769	}
				7770	postIndex := iNdEx + msglen
				7771	if postIndex > l {
				7772	return io.ErrUnexpectedEOF
				7773	}
				7774	m.Items = append(m.Items, PartialObjectMetadata{})
				7775	if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				7776	return err
				7777	}
				7778	iNdEx = postIndex
				7779	default:
				7780	iNdEx = preIndex
				7781	skippy, err := skipGenerated(dAtA[iNdEx:])
				7782	if err != nil {
				7783	return err
				7784	}
				7785	if skippy < 0 {
				7786	return ErrInvalidLengthGenerated
				7787	}
				7788	if (iNdEx + skippy) > l {
				7789	return io.ErrUnexpectedEOF
				7790	}
				7791	iNdEx += skippy
				7792	}
				7793	}
				7794
				7795	if iNdEx > l {
				7796	return io.ErrUnexpectedEOF
				7797	}
				7798	return nil
				7799	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7800	func (m *Patch) Unmarshal(dAtA []byte) error {
				7801	l := len(dAtA)
				7802	iNdEx := 0
				7803	for iNdEx < l {
				7804	preIndex := iNdEx
				7805	var wire uint64
				7806	for shift := uint(0); ; shift += 7 {
				7807	if shift >= 64 {
				7808	return ErrIntOverflowGenerated
				7809	}
				7810	if iNdEx >= l {
				7811	return io.ErrUnexpectedEOF
				7812	}
				7813	b := dAtA[iNdEx]
				7814	iNdEx++
				7815	wire \|= (uint64(b) & 0x7F) << shift
				7816	if b < 0x80 {
				7817	break
				7818	}
				7819	}
				7820	fieldNum := int32(wire >> 3)
				7821	wireType := int(wire & 0x7)
				7822	if wireType == 4 {
				7823	return fmt.Errorf("proto: Patch: wiretype end group for non-group")
				7824	}
				7825	if fieldNum <= 0 {
				7826	return fmt.Errorf("proto: Patch: illegal tag %d (wire type %d)", fieldNum, wire)
				7827	}
				7828	switch fieldNum {
				7829	default:
				7830	iNdEx = preIndex
				7831	skippy, err := skipGenerated(dAtA[iNdEx:])
				7832	if err != nil {
				7833	return err
				7834	}
				7835	if skippy < 0 {
				7836	return ErrInvalidLengthGenerated
				7837	}
				7838	if (iNdEx + skippy) > l {
				7839	return io.ErrUnexpectedEOF
				7840	}
				7841	iNdEx += skippy
				7842	}
				7843	}
				7844
				7845	if iNdEx > l {
				7846	return io.ErrUnexpectedEOF
				7847	}
				7848	return nil
				7849	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	7850	func (m *PatchOptions) Unmarshal(dAtA []byte) error {
				7851	l := len(dAtA)
				7852	iNdEx := 0
				7853	for iNdEx < l {
				7854	preIndex := iNdEx
				7855	var wire uint64
				7856	for shift := uint(0); ; shift += 7 {
				7857	if shift >= 64 {
				7858	return ErrIntOverflowGenerated
				7859	}
				7860	if iNdEx >= l {
				7861	return io.ErrUnexpectedEOF
				7862	}
				7863	b := dAtA[iNdEx]
				7864	iNdEx++
				7865	wire \|= (uint64(b) & 0x7F) << shift
				7866	if b < 0x80 {
				7867	break
				7868	}
				7869	}
				7870	fieldNum := int32(wire >> 3)
				7871	wireType := int(wire & 0x7)
				7872	if wireType == 4 {
				7873	return fmt.Errorf("proto: PatchOptions: wiretype end group for non-group")
				7874	}
				7875	if fieldNum <= 0 {
				7876	return fmt.Errorf("proto: PatchOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				7877	}
				7878	switch fieldNum {
				7879	case 1:
				7880	if wireType != 2 {
				7881	return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
				7882	}
				7883	var stringLen uint64
				7884	for shift := uint(0); ; shift += 7 {
				7885	if shift >= 64 {
				7886	return ErrIntOverflowGenerated
				7887	}
				7888	if iNdEx >= l {
				7889	return io.ErrUnexpectedEOF
				7890	}
				7891	b := dAtA[iNdEx]
				7892	iNdEx++
				7893	stringLen \|= (uint64(b) & 0x7F) << shift
				7894	if b < 0x80 {
				7895	break
				7896	}
				7897	}
				7898	intStringLen := int(stringLen)
				7899	if intStringLen < 0 {
				7900	return ErrInvalidLengthGenerated
				7901	}
				7902	postIndex := iNdEx + intStringLen
				7903	if postIndex > l {
				7904	return io.ErrUnexpectedEOF
				7905	}
				7906	m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
				7907	iNdEx = postIndex
				7908	case 2:
				7909	if wireType != 0 {
				7910	return fmt.Errorf("proto: wrong wireType = %d for field Force", wireType)
				7911	}
				7912	var v int
				7913	for shift := uint(0); ; shift += 7 {
				7914	if shift >= 64 {
				7915	return ErrIntOverflowGenerated
				7916	}
				7917	if iNdEx >= l {
				7918	return io.ErrUnexpectedEOF
				7919	}
				7920	b := dAtA[iNdEx]
				7921	iNdEx++
				7922	v \|= (int(b) & 0x7F) << shift
				7923	if b < 0x80 {
				7924	break
				7925	}
				7926	}
				7927	b := bool(v != 0)
				7928	m.Force = &b
				7929	case 3:
				7930	if wireType != 2 {
				7931	return fmt.Errorf("proto: wrong wireType = %d for field FieldManager", wireType)
				7932	}
				7933	var stringLen uint64
				7934	for shift := uint(0); ; shift += 7 {
				7935	if shift >= 64 {
				7936	return ErrIntOverflowGenerated
				7937	}
				7938	if iNdEx >= l {
				7939	return io.ErrUnexpectedEOF
				7940	}
				7941	b := dAtA[iNdEx]
				7942	iNdEx++
				7943	stringLen \|= (uint64(b) & 0x7F) << shift
				7944	if b < 0x80 {
				7945	break
				7946	}
				7947	}
				7948	intStringLen := int(stringLen)
				7949	if intStringLen < 0 {
				7950	return ErrInvalidLengthGenerated
				7951	}
				7952	postIndex := iNdEx + intStringLen
				7953	if postIndex > l {
				7954	return io.ErrUnexpectedEOF
				7955	}
				7956	m.FieldManager = string(dAtA[iNdEx:postIndex])
				7957	iNdEx = postIndex
				7958	default:
				7959	iNdEx = preIndex
				7960	skippy, err := skipGenerated(dAtA[iNdEx:])
				7961	if err != nil {
				7962	return err
				7963	}
				7964	if skippy < 0 {
				7965	return ErrInvalidLengthGenerated
				7966	}
				7967	if (iNdEx + skippy) > l {
				7968	return io.ErrUnexpectedEOF
				7969	}
				7970	iNdEx += skippy
				7971	}
				7972	}
				7973
				7974	if iNdEx > l {
				7975	return io.ErrUnexpectedEOF
				7976	}
				7977	return nil
				7978	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	7979	func (m *Preconditions) Unmarshal(dAtA []byte) error {
				7980	l := len(dAtA)
				7981	iNdEx := 0
				7982	for iNdEx < l {
				7983	preIndex := iNdEx
				7984	var wire uint64
				7985	for shift := uint(0); ; shift += 7 {
				7986	if shift >= 64 {
				7987	return ErrIntOverflowGenerated
				7988	}
				7989	if iNdEx >= l {
				7990	return io.ErrUnexpectedEOF
				7991	}
				7992	b := dAtA[iNdEx]
				7993	iNdEx++
				7994	wire \|= (uint64(b) & 0x7F) << shift
				7995	if b < 0x80 {
				7996	break
				7997	}
				7998	}
				7999	fieldNum := int32(wire >> 3)
				8000	wireType := int(wire & 0x7)
				8001	if wireType == 4 {
				8002	return fmt.Errorf("proto: Preconditions: wiretype end group for non-group")
				8003	}
				8004	if fieldNum <= 0 {
				8005	return fmt.Errorf("proto: Preconditions: illegal tag %d (wire type %d)", fieldNum, wire)
				8006	}
				8007	switch fieldNum {
				8008	case 1:
				8009	if wireType != 2 {
				8010	return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
				8011	}
				8012	var stringLen uint64
				8013	for shift := uint(0); ; shift += 7 {
				8014	if shift >= 64 {
				8015	return ErrIntOverflowGenerated
				8016	}
				8017	if iNdEx >= l {
				8018	return io.ErrUnexpectedEOF
				8019	}
				8020	b := dAtA[iNdEx]
				8021	iNdEx++
				8022	stringLen \|= (uint64(b) & 0x7F) << shift
				8023	if b < 0x80 {
				8024	break
				8025	}
				8026	}
				8027	intStringLen := int(stringLen)
				8028	if intStringLen < 0 {
				8029	return ErrInvalidLengthGenerated
				8030	}
				8031	postIndex := iNdEx + intStringLen
				8032	if postIndex > l {
				8033	return io.ErrUnexpectedEOF
				8034	}
				8035	s := k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
				8036	m.UID = &s
				8037	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	8038	case 2:
				8039	if wireType != 2 {
				8040	return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
				8041	}
				8042	var stringLen uint64
				8043	for shift := uint(0); ; shift += 7 {
				8044	if shift >= 64 {
				8045	return ErrIntOverflowGenerated
				8046	}
				8047	if iNdEx >= l {
				8048	return io.ErrUnexpectedEOF
				8049	}
				8050	b := dAtA[iNdEx]
				8051	iNdEx++
				8052	stringLen \|= (uint64(b) & 0x7F) << shift
				8053	if b < 0x80 {
				8054	break
				8055	}
				8056	}
				8057	intStringLen := int(stringLen)
				8058	if intStringLen < 0 {
				8059	return ErrInvalidLengthGenerated
				8060	}
				8061	postIndex := iNdEx + intStringLen
				8062	if postIndex > l {
				8063	return io.ErrUnexpectedEOF
				8064	}
				8065	s := string(dAtA[iNdEx:postIndex])
				8066	m.ResourceVersion = &s
				8067	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	8068	default:
				8069	iNdEx = preIndex
				8070	skippy, err := skipGenerated(dAtA[iNdEx:])
				8071	if err != nil {
				8072	return err
				8073	}
				8074	if skippy < 0 {
				8075	return ErrInvalidLengthGenerated
				8076	}
				8077	if (iNdEx + skippy) > l {
				8078	return io.ErrUnexpectedEOF
				8079	}
				8080	iNdEx += skippy
				8081	}
				8082	}
				8083
				8084	if iNdEx > l {
				8085	return io.ErrUnexpectedEOF
				8086	}
				8087	return nil
				8088	}
				8089	func (m *RootPaths) Unmarshal(dAtA []byte) error {
				8090	l := len(dAtA)
				8091	iNdEx := 0
				8092	for iNdEx < l {
				8093	preIndex := iNdEx
				8094	var wire uint64
				8095	for shift := uint(0); ; shift += 7 {
				8096	if shift >= 64 {
				8097	return ErrIntOverflowGenerated
				8098	}
				8099	if iNdEx >= l {
				8100	return io.ErrUnexpectedEOF
				8101	}
				8102	b := dAtA[iNdEx]
				8103	iNdEx++
				8104	wire \|= (uint64(b) & 0x7F) << shift
				8105	if b < 0x80 {
				8106	break
				8107	}
				8108	}
				8109	fieldNum := int32(wire >> 3)
				8110	wireType := int(wire & 0x7)
				8111	if wireType == 4 {
				8112	return fmt.Errorf("proto: RootPaths: wiretype end group for non-group")
				8113	}
				8114	if fieldNum <= 0 {
				8115	return fmt.Errorf("proto: RootPaths: illegal tag %d (wire type %d)", fieldNum, wire)
				8116	}
				8117	switch fieldNum {
				8118	case 1:
				8119	if wireType != 2 {
				8120	return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
				8121	}
				8122	var stringLen uint64
				8123	for shift := uint(0); ; shift += 7 {
				8124	if shift >= 64 {
				8125	return ErrIntOverflowGenerated
				8126	}
				8127	if iNdEx >= l {
				8128	return io.ErrUnexpectedEOF
				8129	}
				8130	b := dAtA[iNdEx]
				8131	iNdEx++
				8132	stringLen \|= (uint64(b) & 0x7F) << shift
				8133	if b < 0x80 {
				8134	break
				8135	}
				8136	}
				8137	intStringLen := int(stringLen)
				8138	if intStringLen < 0 {
				8139	return ErrInvalidLengthGenerated
				8140	}
				8141	postIndex := iNdEx + intStringLen
				8142	if postIndex > l {
				8143	return io.ErrUnexpectedEOF
				8144	}
				8145	m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
				8146	iNdEx = postIndex
				8147	default:
				8148	iNdEx = preIndex
				8149	skippy, err := skipGenerated(dAtA[iNdEx:])
				8150	if err != nil {
				8151	return err
				8152	}
				8153	if skippy < 0 {
				8154	return ErrInvalidLengthGenerated
				8155	}
				8156	if (iNdEx + skippy) > l {
				8157	return io.ErrUnexpectedEOF
				8158	}
				8159	iNdEx += skippy
				8160	}
				8161	}
				8162
				8163	if iNdEx > l {
				8164	return io.ErrUnexpectedEOF
				8165	}
				8166	return nil
				8167	}
				8168	func (m *ServerAddressByClientCIDR) Unmarshal(dAtA []byte) error {
				8169	l := len(dAtA)
				8170	iNdEx := 0
				8171	for iNdEx < l {
				8172	preIndex := iNdEx
				8173	var wire uint64
				8174	for shift := uint(0); ; shift += 7 {
				8175	if shift >= 64 {
				8176	return ErrIntOverflowGenerated
				8177	}
				8178	if iNdEx >= l {
				8179	return io.ErrUnexpectedEOF
				8180	}
				8181	b := dAtA[iNdEx]
				8182	iNdEx++
				8183	wire \|= (uint64(b) & 0x7F) << shift
				8184	if b < 0x80 {
				8185	break
				8186	}
				8187	}
				8188	fieldNum := int32(wire >> 3)
				8189	wireType := int(wire & 0x7)
				8190	if wireType == 4 {
				8191	return fmt.Errorf("proto: ServerAddressByClientCIDR: wiretype end group for non-group")
				8192	}
				8193	if fieldNum <= 0 {
				8194	return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
				8195	}
				8196	switch fieldNum {
				8197	case 1:
				8198	if wireType != 2 {
				8199	return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType)
				8200	}
				8201	var stringLen uint64
				8202	for shift := uint(0); ; shift += 7 {
				8203	if shift >= 64 {
				8204	return ErrIntOverflowGenerated
				8205	}
				8206	if iNdEx >= l {
				8207	return io.ErrUnexpectedEOF
				8208	}
				8209	b := dAtA[iNdEx]
				8210	iNdEx++
				8211	stringLen \|= (uint64(b) & 0x7F) << shift
				8212	if b < 0x80 {
				8213	break
				8214	}
				8215	}
				8216	intStringLen := int(stringLen)
				8217	if intStringLen < 0 {
				8218	return ErrInvalidLengthGenerated
				8219	}
				8220	postIndex := iNdEx + intStringLen
				8221	if postIndex > l {
				8222	return io.ErrUnexpectedEOF
				8223	}
				8224	m.ClientCIDR = string(dAtA[iNdEx:postIndex])
				8225	iNdEx = postIndex
				8226	case 2:
				8227	if wireType != 2 {
				8228	return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType)
				8229	}
				8230	var stringLen uint64
				8231	for shift := uint(0); ; shift += 7 {
				8232	if shift >= 64 {
				8233	return ErrIntOverflowGenerated
				8234	}
				8235	if iNdEx >= l {
				8236	return io.ErrUnexpectedEOF
				8237	}
				8238	b := dAtA[iNdEx]
				8239	iNdEx++
				8240	stringLen \|= (uint64(b) & 0x7F) << shift
				8241	if b < 0x80 {
				8242	break
				8243	}
				8244	}
				8245	intStringLen := int(stringLen)
				8246	if intStringLen < 0 {
				8247	return ErrInvalidLengthGenerated
				8248	}
				8249	postIndex := iNdEx + intStringLen
				8250	if postIndex > l {
				8251	return io.ErrUnexpectedEOF
				8252	}
				8253	m.ServerAddress = string(dAtA[iNdEx:postIndex])
				8254	iNdEx = postIndex
				8255	default:
				8256	iNdEx = preIndex
				8257	skippy, err := skipGenerated(dAtA[iNdEx:])
				8258	if err != nil {
				8259	return err
				8260	}
				8261	if skippy < 0 {
				8262	return ErrInvalidLengthGenerated
				8263	}
				8264	if (iNdEx + skippy) > l {
				8265	return io.ErrUnexpectedEOF
				8266	}
				8267	iNdEx += skippy
				8268	}
				8269	}
				8270
				8271	if iNdEx > l {
				8272	return io.ErrUnexpectedEOF
				8273	}
				8274	return nil
				8275	}
				8276	func (m *Status) Unmarshal(dAtA []byte) error {
				8277	l := len(dAtA)
				8278	iNdEx := 0
				8279	for iNdEx < l {
				8280	preIndex := iNdEx
				8281	var wire uint64
				8282	for shift := uint(0); ; shift += 7 {
				8283	if shift >= 64 {
				8284	return ErrIntOverflowGenerated
				8285	}
				8286	if iNdEx >= l {
				8287	return io.ErrUnexpectedEOF
				8288	}
				8289	b := dAtA[iNdEx]
				8290	iNdEx++
				8291	wire \|= (uint64(b) & 0x7F) << shift
				8292	if b < 0x80 {
				8293	break
				8294	}
				8295	}
				8296	fieldNum := int32(wire >> 3)
				8297	wireType := int(wire & 0x7)
				8298	if wireType == 4 {
				8299	return fmt.Errorf("proto: Status: wiretype end group for non-group")
				8300	}
				8301	if fieldNum <= 0 {
				8302	return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
				8303	}
				8304	switch fieldNum {
				8305	case 1:
				8306	if wireType != 2 {
				8307	return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
				8308	}
				8309	var msglen int
				8310	for shift := uint(0); ; shift += 7 {
				8311	if shift >= 64 {
				8312	return ErrIntOverflowGenerated
				8313	}
				8314	if iNdEx >= l {
				8315	return io.ErrUnexpectedEOF
				8316	}
				8317	b := dAtA[iNdEx]
				8318	iNdEx++
				8319	msglen \|= (int(b) & 0x7F) << shift
				8320	if b < 0x80 {
				8321	break
				8322	}
				8323	}
				8324	if msglen < 0 {
				8325	return ErrInvalidLengthGenerated
				8326	}
				8327	postIndex := iNdEx + msglen
				8328	if postIndex > l {
				8329	return io.ErrUnexpectedEOF
				8330	}
				8331	if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				8332	return err
				8333	}
				8334	iNdEx = postIndex
				8335	case 2:
				8336	if wireType != 2 {
				8337	return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
				8338	}
				8339	var stringLen uint64
				8340	for shift := uint(0); ; shift += 7 {
				8341	if shift >= 64 {
				8342	return ErrIntOverflowGenerated
				8343	}
				8344	if iNdEx >= l {
				8345	return io.ErrUnexpectedEOF
				8346	}
				8347	b := dAtA[iNdEx]
				8348	iNdEx++
				8349	stringLen \|= (uint64(b) & 0x7F) << shift
				8350	if b < 0x80 {
				8351	break
				8352	}
				8353	}
				8354	intStringLen := int(stringLen)
				8355	if intStringLen < 0 {
				8356	return ErrInvalidLengthGenerated
				8357	}
				8358	postIndex := iNdEx + intStringLen
				8359	if postIndex > l {
				8360	return io.ErrUnexpectedEOF
				8361	}
				8362	m.Status = string(dAtA[iNdEx:postIndex])
				8363	iNdEx = postIndex
				8364	case 3:
				8365	if wireType != 2 {
				8366	return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
				8367	}
				8368	var stringLen uint64
				8369	for shift := uint(0); ; shift += 7 {
				8370	if shift >= 64 {
				8371	return ErrIntOverflowGenerated
				8372	}
				8373	if iNdEx >= l {
				8374	return io.ErrUnexpectedEOF
				8375	}
				8376	b := dAtA[iNdEx]
				8377	iNdEx++
				8378	stringLen \|= (uint64(b) & 0x7F) << shift
				8379	if b < 0x80 {
				8380	break
				8381	}
				8382	}
				8383	intStringLen := int(stringLen)
				8384	if intStringLen < 0 {
				8385	return ErrInvalidLengthGenerated
				8386	}
				8387	postIndex := iNdEx + intStringLen
				8388	if postIndex > l {
				8389	return io.ErrUnexpectedEOF
				8390	}
				8391	m.Message = string(dAtA[iNdEx:postIndex])
				8392	iNdEx = postIndex
				8393	case 4:
				8394	if wireType != 2 {
				8395	return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
				8396	}
				8397	var stringLen uint64
				8398	for shift := uint(0); ; shift += 7 {
				8399	if shift >= 64 {
				8400	return ErrIntOverflowGenerated
				8401	}
				8402	if iNdEx >= l {
				8403	return io.ErrUnexpectedEOF
				8404	}
				8405	b := dAtA[iNdEx]
				8406	iNdEx++
				8407	stringLen \|= (uint64(b) & 0x7F) << shift
				8408	if b < 0x80 {
				8409	break
				8410	}
				8411	}
				8412	intStringLen := int(stringLen)
				8413	if intStringLen < 0 {
				8414	return ErrInvalidLengthGenerated
				8415	}
				8416	postIndex := iNdEx + intStringLen
				8417	if postIndex > l {
				8418	return io.ErrUnexpectedEOF
				8419	}
				8420	m.Reason = StatusReason(dAtA[iNdEx:postIndex])
				8421	iNdEx = postIndex
				8422	case 5:
				8423	if wireType != 2 {
				8424	return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
				8425	}
				8426	var msglen int
				8427	for shift := uint(0); ; shift += 7 {
				8428	if shift >= 64 {
				8429	return ErrIntOverflowGenerated
				8430	}
				8431	if iNdEx >= l {
				8432	return io.ErrUnexpectedEOF
				8433	}
				8434	b := dAtA[iNdEx]
				8435	iNdEx++
				8436	msglen \|= (int(b) & 0x7F) << shift
				8437	if b < 0x80 {
				8438	break
				8439	}
				8440	}
				8441	if msglen < 0 {
				8442	return ErrInvalidLengthGenerated
				8443	}
				8444	postIndex := iNdEx + msglen
				8445	if postIndex > l {
				8446	return io.ErrUnexpectedEOF
				8447	}
				8448	if m.Details == nil {
				8449	m.Details = &StatusDetails{}
				8450	}
				8451	if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				8452	return err
				8453	}
				8454	iNdEx = postIndex
				8455	case 6:
				8456	if wireType != 0 {
				8457	return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
				8458	}
				8459	m.Code = 0
				8460	for shift := uint(0); ; shift += 7 {
				8461	if shift >= 64 {
				8462	return ErrIntOverflowGenerated
				8463	}
				8464	if iNdEx >= l {
				8465	return io.ErrUnexpectedEOF
				8466	}
				8467	b := dAtA[iNdEx]
				8468	iNdEx++
				8469	m.Code \|= (int32(b) & 0x7F) << shift
				8470	if b < 0x80 {
				8471	break
				8472	}
				8473	}
				8474	default:
				8475	iNdEx = preIndex
				8476	skippy, err := skipGenerated(dAtA[iNdEx:])
				8477	if err != nil {
				8478	return err
				8479	}
				8480	if skippy < 0 {
				8481	return ErrInvalidLengthGenerated
				8482	}
				8483	if (iNdEx + skippy) > l {
				8484	return io.ErrUnexpectedEOF
				8485	}
				8486	iNdEx += skippy
				8487	}
				8488	}
				8489
				8490	if iNdEx > l {
				8491	return io.ErrUnexpectedEOF
				8492	}
				8493	return nil
				8494	}
				8495	func (m *StatusCause) Unmarshal(dAtA []byte) error {
				8496	l := len(dAtA)
				8497	iNdEx := 0
				8498	for iNdEx < l {
				8499	preIndex := iNdEx
				8500	var wire uint64
				8501	for shift := uint(0); ; shift += 7 {
				8502	if shift >= 64 {
				8503	return ErrIntOverflowGenerated
				8504	}
				8505	if iNdEx >= l {
				8506	return io.ErrUnexpectedEOF
				8507	}
				8508	b := dAtA[iNdEx]
				8509	iNdEx++
				8510	wire \|= (uint64(b) & 0x7F) << shift
				8511	if b < 0x80 {
				8512	break
				8513	}
				8514	}
				8515	fieldNum := int32(wire >> 3)
				8516	wireType := int(wire & 0x7)
				8517	if wireType == 4 {
				8518	return fmt.Errorf("proto: StatusCause: wiretype end group for non-group")
				8519	}
				8520	if fieldNum <= 0 {
				8521	return fmt.Errorf("proto: StatusCause: illegal tag %d (wire type %d)", fieldNum, wire)
				8522	}
				8523	switch fieldNum {
				8524	case 1:
				8525	if wireType != 2 {
				8526	return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
				8527	}
				8528	var stringLen uint64
				8529	for shift := uint(0); ; shift += 7 {
				8530	if shift >= 64 {
				8531	return ErrIntOverflowGenerated
				8532	}
				8533	if iNdEx >= l {
				8534	return io.ErrUnexpectedEOF
				8535	}
				8536	b := dAtA[iNdEx]
				8537	iNdEx++
				8538	stringLen \|= (uint64(b) & 0x7F) << shift
				8539	if b < 0x80 {
				8540	break
				8541	}
				8542	}
				8543	intStringLen := int(stringLen)
				8544	if intStringLen < 0 {
				8545	return ErrInvalidLengthGenerated
				8546	}
				8547	postIndex := iNdEx + intStringLen
				8548	if postIndex > l {
				8549	return io.ErrUnexpectedEOF
				8550	}
				8551	m.Type = CauseType(dAtA[iNdEx:postIndex])
				8552	iNdEx = postIndex
				8553	case 2:
				8554	if wireType != 2 {
				8555	return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
				8556	}
				8557	var stringLen uint64
				8558	for shift := uint(0); ; shift += 7 {
				8559	if shift >= 64 {
				8560	return ErrIntOverflowGenerated
				8561	}
				8562	if iNdEx >= l {
				8563	return io.ErrUnexpectedEOF
				8564	}
				8565	b := dAtA[iNdEx]
				8566	iNdEx++
				8567	stringLen \|= (uint64(b) & 0x7F) << shift
				8568	if b < 0x80 {
				8569	break
				8570	}
				8571	}
				8572	intStringLen := int(stringLen)
				8573	if intStringLen < 0 {
				8574	return ErrInvalidLengthGenerated
				8575	}
				8576	postIndex := iNdEx + intStringLen
				8577	if postIndex > l {
				8578	return io.ErrUnexpectedEOF
				8579	}
				8580	m.Message = string(dAtA[iNdEx:postIndex])
				8581	iNdEx = postIndex
				8582	case 3:
				8583	if wireType != 2 {
				8584	return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
				8585	}
				8586	var stringLen uint64
				8587	for shift := uint(0); ; shift += 7 {
				8588	if shift >= 64 {
				8589	return ErrIntOverflowGenerated
				8590	}
				8591	if iNdEx >= l {
				8592	return io.ErrUnexpectedEOF
				8593	}
				8594	b := dAtA[iNdEx]
				8595	iNdEx++
				8596	stringLen \|= (uint64(b) & 0x7F) << shift
				8597	if b < 0x80 {
				8598	break
				8599	}
				8600	}
				8601	intStringLen := int(stringLen)
				8602	if intStringLen < 0 {
				8603	return ErrInvalidLengthGenerated
				8604	}
				8605	postIndex := iNdEx + intStringLen
				8606	if postIndex > l {
				8607	return io.ErrUnexpectedEOF
				8608	}
				8609	m.Field = string(dAtA[iNdEx:postIndex])
				8610	iNdEx = postIndex
				8611	default:
				8612	iNdEx = preIndex
				8613	skippy, err := skipGenerated(dAtA[iNdEx:])
				8614	if err != nil {
				8615	return err
				8616	}
				8617	if skippy < 0 {
				8618	return ErrInvalidLengthGenerated
				8619	}
				8620	if (iNdEx + skippy) > l {
				8621	return io.ErrUnexpectedEOF
				8622	}
				8623	iNdEx += skippy
				8624	}
				8625	}
				8626
				8627	if iNdEx > l {
				8628	return io.ErrUnexpectedEOF
				8629	}
				8630	return nil
				8631	}
				8632	func (m *StatusDetails) Unmarshal(dAtA []byte) error {
				8633	l := len(dAtA)
				8634	iNdEx := 0
				8635	for iNdEx < l {
				8636	preIndex := iNdEx
				8637	var wire uint64
				8638	for shift := uint(0); ; shift += 7 {
				8639	if shift >= 64 {
				8640	return ErrIntOverflowGenerated
				8641	}
				8642	if iNdEx >= l {
				8643	return io.ErrUnexpectedEOF
				8644	}
				8645	b := dAtA[iNdEx]
				8646	iNdEx++
				8647	wire \|= (uint64(b) & 0x7F) << shift
				8648	if b < 0x80 {
				8649	break
				8650	}
				8651	}
				8652	fieldNum := int32(wire >> 3)
				8653	wireType := int(wire & 0x7)
				8654	if wireType == 4 {
				8655	return fmt.Errorf("proto: StatusDetails: wiretype end group for non-group")
				8656	}
				8657	if fieldNum <= 0 {
				8658	return fmt.Errorf("proto: StatusDetails: illegal tag %d (wire type %d)", fieldNum, wire)
				8659	}
				8660	switch fieldNum {
				8661	case 1:
				8662	if wireType != 2 {
				8663	return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				8664	}
				8665	var stringLen uint64
				8666	for shift := uint(0); ; shift += 7 {
				8667	if shift >= 64 {
				8668	return ErrIntOverflowGenerated
				8669	}
				8670	if iNdEx >= l {
				8671	return io.ErrUnexpectedEOF
				8672	}
				8673	b := dAtA[iNdEx]
				8674	iNdEx++
				8675	stringLen \|= (uint64(b) & 0x7F) << shift
				8676	if b < 0x80 {
				8677	break
				8678	}
				8679	}
				8680	intStringLen := int(stringLen)
				8681	if intStringLen < 0 {
				8682	return ErrInvalidLengthGenerated
				8683	}
				8684	postIndex := iNdEx + intStringLen
				8685	if postIndex > l {
				8686	return io.ErrUnexpectedEOF
				8687	}
				8688	m.Name = string(dAtA[iNdEx:postIndex])
				8689	iNdEx = postIndex
				8690	case 2:
				8691	if wireType != 2 {
				8692	return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
				8693	}
				8694	var stringLen uint64
				8695	for shift := uint(0); ; shift += 7 {
				8696	if shift >= 64 {
				8697	return ErrIntOverflowGenerated
				8698	}
				8699	if iNdEx >= l {
				8700	return io.ErrUnexpectedEOF
				8701	}
				8702	b := dAtA[iNdEx]
				8703	iNdEx++
				8704	stringLen \|= (uint64(b) & 0x7F) << shift
				8705	if b < 0x80 {
				8706	break
				8707	}
				8708	}
				8709	intStringLen := int(stringLen)
				8710	if intStringLen < 0 {
				8711	return ErrInvalidLengthGenerated
				8712	}
				8713	postIndex := iNdEx + intStringLen
				8714	if postIndex > l {
				8715	return io.ErrUnexpectedEOF
				8716	}
				8717	m.Group = string(dAtA[iNdEx:postIndex])
				8718	iNdEx = postIndex
				8719	case 3:
				8720	if wireType != 2 {
				8721	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				8722	}
				8723	var stringLen uint64
				8724	for shift := uint(0); ; shift += 7 {
				8725	if shift >= 64 {
				8726	return ErrIntOverflowGenerated
				8727	}
				8728	if iNdEx >= l {
				8729	return io.ErrUnexpectedEOF
				8730	}
				8731	b := dAtA[iNdEx]
				8732	iNdEx++
				8733	stringLen \|= (uint64(b) & 0x7F) << shift
				8734	if b < 0x80 {
				8735	break
				8736	}
				8737	}
				8738	intStringLen := int(stringLen)
				8739	if intStringLen < 0 {
				8740	return ErrInvalidLengthGenerated
				8741	}
				8742	postIndex := iNdEx + intStringLen
				8743	if postIndex > l {
				8744	return io.ErrUnexpectedEOF
				8745	}
				8746	m.Kind = string(dAtA[iNdEx:postIndex])
				8747	iNdEx = postIndex
				8748	case 4:
				8749	if wireType != 2 {
				8750	return fmt.Errorf("proto: wrong wireType = %d for field Causes", wireType)
				8751	}
				8752	var msglen int
				8753	for shift := uint(0); ; shift += 7 {
				8754	if shift >= 64 {
				8755	return ErrIntOverflowGenerated
				8756	}
				8757	if iNdEx >= l {
				8758	return io.ErrUnexpectedEOF
				8759	}
				8760	b := dAtA[iNdEx]
				8761	iNdEx++
				8762	msglen \|= (int(b) & 0x7F) << shift
				8763	if b < 0x80 {
				8764	break
				8765	}
				8766	}
				8767	if msglen < 0 {
				8768	return ErrInvalidLengthGenerated
				8769	}
				8770	postIndex := iNdEx + msglen
				8771	if postIndex > l {
				8772	return io.ErrUnexpectedEOF
				8773	}
				8774	m.Causes = append(m.Causes, StatusCause{})
				8775	if err := m.Causes[len(m.Causes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				8776	return err
				8777	}
				8778	iNdEx = postIndex
				8779	case 5:
				8780	if wireType != 0 {
				8781	return fmt.Errorf("proto: wrong wireType = %d for field RetryAfterSeconds", wireType)
				8782	}
				8783	m.RetryAfterSeconds = 0
				8784	for shift := uint(0); ; shift += 7 {
				8785	if shift >= 64 {
				8786	return ErrIntOverflowGenerated
				8787	}
				8788	if iNdEx >= l {
				8789	return io.ErrUnexpectedEOF
				8790	}
				8791	b := dAtA[iNdEx]
				8792	iNdEx++
				8793	m.RetryAfterSeconds \|= (int32(b) & 0x7F) << shift
				8794	if b < 0x80 {
				8795	break
				8796	}
				8797	}
				8798	case 6:
				8799	if wireType != 2 {
				8800	return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
				8801	}
				8802	var stringLen uint64
				8803	for shift := uint(0); ; shift += 7 {
				8804	if shift >= 64 {
				8805	return ErrIntOverflowGenerated
				8806	}
				8807	if iNdEx >= l {
				8808	return io.ErrUnexpectedEOF
				8809	}
				8810	b := dAtA[iNdEx]
				8811	iNdEx++
				8812	stringLen \|= (uint64(b) & 0x7F) << shift
				8813	if b < 0x80 {
				8814	break
				8815	}
				8816	}
				8817	intStringLen := int(stringLen)
				8818	if intStringLen < 0 {
				8819	return ErrInvalidLengthGenerated
				8820	}
				8821	postIndex := iNdEx + intStringLen
				8822	if postIndex > l {
				8823	return io.ErrUnexpectedEOF
				8824	}
				8825	m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
				8826	iNdEx = postIndex
				8827	default:
				8828	iNdEx = preIndex
				8829	skippy, err := skipGenerated(dAtA[iNdEx:])
				8830	if err != nil {
				8831	return err
				8832	}
				8833	if skippy < 0 {
				8834	return ErrInvalidLengthGenerated
				8835	}
				8836	if (iNdEx + skippy) > l {
				8837	return io.ErrUnexpectedEOF
				8838	}
				8839	iNdEx += skippy
				8840	}
				8841	}
				8842
				8843	if iNdEx > l {
				8844	return io.ErrUnexpectedEOF
				8845	}
				8846	return nil
				8847	}
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	8848	func (m *TableOptions) Unmarshal(dAtA []byte) error {
				8849	l := len(dAtA)
				8850	iNdEx := 0
				8851	for iNdEx < l {
				8852	preIndex := iNdEx
				8853	var wire uint64
				8854	for shift := uint(0); ; shift += 7 {
				8855	if shift >= 64 {
				8856	return ErrIntOverflowGenerated
				8857	}
				8858	if iNdEx >= l {
				8859	return io.ErrUnexpectedEOF
				8860	}
				8861	b := dAtA[iNdEx]
				8862	iNdEx++
				8863	wire \|= (uint64(b) & 0x7F) << shift
				8864	if b < 0x80 {
				8865	break
				8866	}
				8867	}
				8868	fieldNum := int32(wire >> 3)
				8869	wireType := int(wire & 0x7)
				8870	if wireType == 4 {
				8871	return fmt.Errorf("proto: TableOptions: wiretype end group for non-group")
				8872	}
				8873	if fieldNum <= 0 {
				8874	return fmt.Errorf("proto: TableOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				8875	}
				8876	switch fieldNum {
				8877	case 1:
				8878	if wireType != 2 {
				8879	return fmt.Errorf("proto: wrong wireType = %d for field IncludeObject", wireType)
				8880	}
				8881	var stringLen uint64
				8882	for shift := uint(0); ; shift += 7 {
				8883	if shift >= 64 {
				8884	return ErrIntOverflowGenerated
				8885	}
				8886	if iNdEx >= l {
				8887	return io.ErrUnexpectedEOF
				8888	}
				8889	b := dAtA[iNdEx]
				8890	iNdEx++
				8891	stringLen \|= (uint64(b) & 0x7F) << shift
				8892	if b < 0x80 {
				8893	break
				8894	}
				8895	}
				8896	intStringLen := int(stringLen)
				8897	if intStringLen < 0 {
				8898	return ErrInvalidLengthGenerated
				8899	}
				8900	postIndex := iNdEx + intStringLen
				8901	if postIndex > l {
				8902	return io.ErrUnexpectedEOF
				8903	}
				8904	m.IncludeObject = IncludeObjectPolicy(dAtA[iNdEx:postIndex])
				8905	iNdEx = postIndex
				8906	default:
				8907	iNdEx = preIndex
				8908	skippy, err := skipGenerated(dAtA[iNdEx:])
				8909	if err != nil {
				8910	return err
				8911	}
				8912	if skippy < 0 {
				8913	return ErrInvalidLengthGenerated
				8914	}
				8915	if (iNdEx + skippy) > l {
				8916	return io.ErrUnexpectedEOF
				8917	}
				8918	iNdEx += skippy
				8919	}
				8920	}
				8921
				8922	if iNdEx > l {
				8923	return io.ErrUnexpectedEOF
				8924	}
				8925	return nil
				8926	}
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	8927	func (m *Timestamp) Unmarshal(dAtA []byte) error {
				8928	l := len(dAtA)
				8929	iNdEx := 0
				8930	for iNdEx < l {
				8931	preIndex := iNdEx
				8932	var wire uint64
				8933	for shift := uint(0); ; shift += 7 {
				8934	if shift >= 64 {
				8935	return ErrIntOverflowGenerated
				8936	}
				8937	if iNdEx >= l {
				8938	return io.ErrUnexpectedEOF
				8939	}
				8940	b := dAtA[iNdEx]
				8941	iNdEx++
				8942	wire \|= (uint64(b) & 0x7F) << shift
				8943	if b < 0x80 {
				8944	break
				8945	}
				8946	}
				8947	fieldNum := int32(wire >> 3)
				8948	wireType := int(wire & 0x7)
				8949	if wireType == 4 {
				8950	return fmt.Errorf("proto: Timestamp: wiretype end group for non-group")
				8951	}
				8952	if fieldNum <= 0 {
				8953	return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire)
				8954	}
				8955	switch fieldNum {
				8956	case 1:
				8957	if wireType != 0 {
				8958	return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType)
				8959	}
				8960	m.Seconds = 0
				8961	for shift := uint(0); ; shift += 7 {
				8962	if shift >= 64 {
				8963	return ErrIntOverflowGenerated
				8964	}
				8965	if iNdEx >= l {
				8966	return io.ErrUnexpectedEOF
				8967	}
				8968	b := dAtA[iNdEx]
				8969	iNdEx++
				8970	m.Seconds \|= (int64(b) & 0x7F) << shift
				8971	if b < 0x80 {
				8972	break
				8973	}
				8974	}
				8975	case 2:
				8976	if wireType != 0 {
				8977	return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType)
				8978	}
				8979	m.Nanos = 0
				8980	for shift := uint(0); ; shift += 7 {
				8981	if shift >= 64 {
				8982	return ErrIntOverflowGenerated
				8983	}
				8984	if iNdEx >= l {
				8985	return io.ErrUnexpectedEOF
				8986	}
				8987	b := dAtA[iNdEx]
				8988	iNdEx++
				8989	m.Nanos \|= (int32(b) & 0x7F) << shift
				8990	if b < 0x80 {
				8991	break
				8992	}
				8993	}
				8994	default:
				8995	iNdEx = preIndex
				8996	skippy, err := skipGenerated(dAtA[iNdEx:])
				8997	if err != nil {
				8998	return err
				8999	}
				9000	if skippy < 0 {
				9001	return ErrInvalidLengthGenerated
				9002	}
				9003	if (iNdEx + skippy) > l {
				9004	return io.ErrUnexpectedEOF
				9005	}
				9006	iNdEx += skippy
				9007	}
				9008	}
				9009
				9010	if iNdEx > l {
				9011	return io.ErrUnexpectedEOF
				9012	}
				9013	return nil
				9014	}
				9015	func (m *TypeMeta) Unmarshal(dAtA []byte) error {
				9016	l := len(dAtA)
				9017	iNdEx := 0
				9018	for iNdEx < l {
				9019	preIndex := iNdEx
				9020	var wire uint64
				9021	for shift := uint(0); ; shift += 7 {
				9022	if shift >= 64 {
				9023	return ErrIntOverflowGenerated
				9024	}
				9025	if iNdEx >= l {
				9026	return io.ErrUnexpectedEOF
				9027	}
				9028	b := dAtA[iNdEx]
				9029	iNdEx++
				9030	wire \|= (uint64(b) & 0x7F) << shift
				9031	if b < 0x80 {
				9032	break
				9033	}
				9034	}
				9035	fieldNum := int32(wire >> 3)
				9036	wireType := int(wire & 0x7)
				9037	if wireType == 4 {
				9038	return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
				9039	}
				9040	if fieldNum <= 0 {
				9041	return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
				9042	}
				9043	switch fieldNum {
				9044	case 1:
				9045	if wireType != 2 {
				9046	return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
				9047	}
				9048	var stringLen uint64
				9049	for shift := uint(0); ; shift += 7 {
				9050	if shift >= 64 {
				9051	return ErrIntOverflowGenerated
				9052	}
				9053	if iNdEx >= l {
				9054	return io.ErrUnexpectedEOF
				9055	}
				9056	b := dAtA[iNdEx]
				9057	iNdEx++
				9058	stringLen \|= (uint64(b) & 0x7F) << shift
				9059	if b < 0x80 {
				9060	break
				9061	}
				9062	}
				9063	intStringLen := int(stringLen)
				9064	if intStringLen < 0 {
				9065	return ErrInvalidLengthGenerated
				9066	}
				9067	postIndex := iNdEx + intStringLen
				9068	if postIndex > l {
				9069	return io.ErrUnexpectedEOF
				9070	}
				9071	m.Kind = string(dAtA[iNdEx:postIndex])
				9072	iNdEx = postIndex
				9073	case 2:
				9074	if wireType != 2 {
				9075	return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
				9076	}
				9077	var stringLen uint64
				9078	for shift := uint(0); ; shift += 7 {
				9079	if shift >= 64 {
				9080	return ErrIntOverflowGenerated
				9081	}
				9082	if iNdEx >= l {
				9083	return io.ErrUnexpectedEOF
				9084	}
				9085	b := dAtA[iNdEx]
				9086	iNdEx++
				9087	stringLen \|= (uint64(b) & 0x7F) << shift
				9088	if b < 0x80 {
				9089	break
				9090	}
				9091	}
				9092	intStringLen := int(stringLen)
				9093	if intStringLen < 0 {
				9094	return ErrInvalidLengthGenerated
				9095	}
				9096	postIndex := iNdEx + intStringLen
				9097	if postIndex > l {
				9098	return io.ErrUnexpectedEOF
				9099	}
				9100	m.APIVersion = string(dAtA[iNdEx:postIndex])
				9101	iNdEx = postIndex
				9102	default:
				9103	iNdEx = preIndex
				9104	skippy, err := skipGenerated(dAtA[iNdEx:])
				9105	if err != nil {
				9106	return err
				9107	}
				9108	if skippy < 0 {
				9109	return ErrInvalidLengthGenerated
				9110	}
				9111	if (iNdEx + skippy) > l {
				9112	return io.ErrUnexpectedEOF
				9113	}
				9114	iNdEx += skippy
				9115	}
				9116	}
				9117
				9118	if iNdEx > l {
				9119	return io.ErrUnexpectedEOF
				9120	}
				9121	return nil
				9122	}
				9123	func (m *UpdateOptions) Unmarshal(dAtA []byte) error {
				9124	l := len(dAtA)
				9125	iNdEx := 0
				9126	for iNdEx < l {
				9127	preIndex := iNdEx
				9128	var wire uint64
				9129	for shift := uint(0); ; shift += 7 {
				9130	if shift >= 64 {
				9131	return ErrIntOverflowGenerated
				9132	}
				9133	if iNdEx >= l {
				9134	return io.ErrUnexpectedEOF
				9135	}
				9136	b := dAtA[iNdEx]
				9137	iNdEx++
				9138	wire \|= (uint64(b) & 0x7F) << shift
				9139	if b < 0x80 {
				9140	break
				9141	}
				9142	}
				9143	fieldNum := int32(wire >> 3)
				9144	wireType := int(wire & 0x7)
				9145	if wireType == 4 {
				9146	return fmt.Errorf("proto: UpdateOptions: wiretype end group for non-group")
				9147	}
				9148	if fieldNum <= 0 {
				9149	return fmt.Errorf("proto: UpdateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
				9150	}
				9151	switch fieldNum {
				9152	case 1:
				9153	if wireType != 2 {
				9154	return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
				9155	}
				9156	var stringLen uint64
				9157	for shift := uint(0); ; shift += 7 {
				9158	if shift >= 64 {
				9159	return ErrIntOverflowGenerated
				9160	}
				9161	if iNdEx >= l {
				9162	return io.ErrUnexpectedEOF
				9163	}
				9164	b := dAtA[iNdEx]
				9165	iNdEx++
				9166	stringLen \|= (uint64(b) & 0x7F) << shift
				9167	if b < 0x80 {
				9168	break
				9169	}
				9170	}
				9171	intStringLen := int(stringLen)
				9172	if intStringLen < 0 {
				9173	return ErrInvalidLengthGenerated
				9174	}
				9175	postIndex := iNdEx + intStringLen
				9176	if postIndex > l {
				9177	return io.ErrUnexpectedEOF
				9178	}
				9179	m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
				9180	iNdEx = postIndex
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	9181	case 2:
				9182	if wireType != 2 {
				9183	return fmt.Errorf("proto: wrong wireType = %d for field FieldManager", wireType)
				9184	}
				9185	var stringLen uint64
				9186	for shift := uint(0); ; shift += 7 {
				9187	if shift >= 64 {
				9188	return ErrIntOverflowGenerated
				9189	}
				9190	if iNdEx >= l {
				9191	return io.ErrUnexpectedEOF
				9192	}
				9193	b := dAtA[iNdEx]
				9194	iNdEx++
				9195	stringLen \|= (uint64(b) & 0x7F) << shift
				9196	if b < 0x80 {
				9197	break
				9198	}
				9199	}
				9200	intStringLen := int(stringLen)
				9201	if intStringLen < 0 {
				9202	return ErrInvalidLengthGenerated
				9203	}
				9204	postIndex := iNdEx + intStringLen
				9205	if postIndex > l {
				9206	return io.ErrUnexpectedEOF
				9207	}
				9208	m.FieldManager = string(dAtA[iNdEx:postIndex])
				9209	iNdEx = postIndex
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	9210	default:
				9211	iNdEx = preIndex
				9212	skippy, err := skipGenerated(dAtA[iNdEx:])
				9213	if err != nil {
				9214	return err
				9215	}
				9216	if skippy < 0 {
				9217	return ErrInvalidLengthGenerated
				9218	}
				9219	if (iNdEx + skippy) > l {
				9220	return io.ErrUnexpectedEOF
				9221	}
				9222	iNdEx += skippy
				9223	}
				9224	}
				9225
				9226	if iNdEx > l {
				9227	return io.ErrUnexpectedEOF
				9228	}
				9229	return nil
				9230	}
				9231	func (m *Verbs) Unmarshal(dAtA []byte) error {
				9232	l := len(dAtA)
				9233	iNdEx := 0
				9234	for iNdEx < l {
				9235	preIndex := iNdEx
				9236	var wire uint64
				9237	for shift := uint(0); ; shift += 7 {
				9238	if shift >= 64 {
				9239	return ErrIntOverflowGenerated
				9240	}
				9241	if iNdEx >= l {
				9242	return io.ErrUnexpectedEOF
				9243	}
				9244	b := dAtA[iNdEx]
				9245	iNdEx++
				9246	wire \|= (uint64(b) & 0x7F) << shift
				9247	if b < 0x80 {
				9248	break
				9249	}
				9250	}
				9251	fieldNum := int32(wire >> 3)
				9252	wireType := int(wire & 0x7)
				9253	if wireType == 4 {
				9254	return fmt.Errorf("proto: Verbs: wiretype end group for non-group")
				9255	}
				9256	if fieldNum <= 0 {
				9257	return fmt.Errorf("proto: Verbs: illegal tag %d (wire type %d)", fieldNum, wire)
				9258	}
				9259	switch fieldNum {
				9260	case 1:
				9261	if wireType != 2 {
				9262	return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
				9263	}
				9264	var stringLen uint64
				9265	for shift := uint(0); ; shift += 7 {
				9266	if shift >= 64 {
				9267	return ErrIntOverflowGenerated
				9268	}
				9269	if iNdEx >= l {
				9270	return io.ErrUnexpectedEOF
				9271	}
				9272	b := dAtA[iNdEx]
				9273	iNdEx++
				9274	stringLen \|= (uint64(b) & 0x7F) << shift
				9275	if b < 0x80 {
				9276	break
				9277	}
				9278	}
				9279	intStringLen := int(stringLen)
				9280	if intStringLen < 0 {
				9281	return ErrInvalidLengthGenerated
				9282	}
				9283	postIndex := iNdEx + intStringLen
				9284	if postIndex > l {
				9285	return io.ErrUnexpectedEOF
				9286	}
				9287	m = append(m, string(dAtA[iNdEx:postIndex]))
				9288	iNdEx = postIndex
				9289	default:
				9290	iNdEx = preIndex
				9291	skippy, err := skipGenerated(dAtA[iNdEx:])
				9292	if err != nil {
				9293	return err
				9294	}
				9295	if skippy < 0 {
				9296	return ErrInvalidLengthGenerated
				9297	}
				9298	if (iNdEx + skippy) > l {
				9299	return io.ErrUnexpectedEOF
				9300	}
				9301	iNdEx += skippy
				9302	}
				9303	}
				9304
				9305	if iNdEx > l {
				9306	return io.ErrUnexpectedEOF
				9307	}
				9308	return nil
				9309	}
				9310	func (m *WatchEvent) Unmarshal(dAtA []byte) error {
				9311	l := len(dAtA)
				9312	iNdEx := 0
				9313	for iNdEx < l {
				9314	preIndex := iNdEx
				9315	var wire uint64
				9316	for shift := uint(0); ; shift += 7 {
				9317	if shift >= 64 {
				9318	return ErrIntOverflowGenerated
				9319	}
				9320	if iNdEx >= l {
				9321	return io.ErrUnexpectedEOF
				9322	}
				9323	b := dAtA[iNdEx]
				9324	iNdEx++
				9325	wire \|= (uint64(b) & 0x7F) << shift
				9326	if b < 0x80 {
				9327	break
				9328	}
				9329	}
				9330	fieldNum := int32(wire >> 3)
				9331	wireType := int(wire & 0x7)
				9332	if wireType == 4 {
				9333	return fmt.Errorf("proto: WatchEvent: wiretype end group for non-group")
				9334	}
				9335	if fieldNum <= 0 {
				9336	return fmt.Errorf("proto: WatchEvent: illegal tag %d (wire type %d)", fieldNum, wire)
				9337	}
				9338	switch fieldNum {
				9339	case 1:
				9340	if wireType != 2 {
				9341	return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
				9342	}
				9343	var stringLen uint64
				9344	for shift := uint(0); ; shift += 7 {
				9345	if shift >= 64 {
				9346	return ErrIntOverflowGenerated
				9347	}
				9348	if iNdEx >= l {
				9349	return io.ErrUnexpectedEOF
				9350	}
				9351	b := dAtA[iNdEx]
				9352	iNdEx++
				9353	stringLen \|= (uint64(b) & 0x7F) << shift
				9354	if b < 0x80 {
				9355	break
				9356	}
				9357	}
				9358	intStringLen := int(stringLen)
				9359	if intStringLen < 0 {
				9360	return ErrInvalidLengthGenerated
				9361	}
				9362	postIndex := iNdEx + intStringLen
				9363	if postIndex > l {
				9364	return io.ErrUnexpectedEOF
				9365	}
				9366	m.Type = string(dAtA[iNdEx:postIndex])
				9367	iNdEx = postIndex
				9368	case 2:
				9369	if wireType != 2 {
				9370	return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
				9371	}
				9372	var msglen int
				9373	for shift := uint(0); ; shift += 7 {
				9374	if shift >= 64 {
				9375	return ErrIntOverflowGenerated
				9376	}
				9377	if iNdEx >= l {
				9378	return io.ErrUnexpectedEOF
				9379	}
				9380	b := dAtA[iNdEx]
				9381	iNdEx++
				9382	msglen \|= (int(b) & 0x7F) << shift
				9383	if b < 0x80 {
				9384	break
				9385	}
				9386	}
				9387	if msglen < 0 {
				9388	return ErrInvalidLengthGenerated
				9389	}
				9390	postIndex := iNdEx + msglen
				9391	if postIndex > l {
				9392	return io.ErrUnexpectedEOF
				9393	}
				9394	if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				9395	return err
				9396	}
				9397	iNdEx = postIndex
				9398	default:
				9399	iNdEx = preIndex
				9400	skippy, err := skipGenerated(dAtA[iNdEx:])
				9401	if err != nil {
				9402	return err
				9403	}
				9404	if skippy < 0 {
				9405	return ErrInvalidLengthGenerated
				9406	}
				9407	if (iNdEx + skippy) > l {
				9408	return io.ErrUnexpectedEOF
				9409	}
				9410	iNdEx += skippy
				9411	}
				9412	}
				9413
				9414	if iNdEx > l {
				9415	return io.ErrUnexpectedEOF
				9416	}
				9417	return nil
				9418	}
				9419	func skipGenerated(dAtA []byte) (n int, err error) {
				9420	l := len(dAtA)
				9421	iNdEx := 0
				9422	for iNdEx < l {
				9423	var wire uint64
				9424	for shift := uint(0); ; shift += 7 {
				9425	if shift >= 64 {
				9426	return 0, ErrIntOverflowGenerated
				9427	}
				9428	if iNdEx >= l {
				9429	return 0, io.ErrUnexpectedEOF
				9430	}
				9431	b := dAtA[iNdEx]
				9432	iNdEx++
				9433	wire \|= (uint64(b) & 0x7F) << shift
				9434	if b < 0x80 {
				9435	break
				9436	}
				9437	}
				9438	wireType := int(wire & 0x7)
				9439	switch wireType {
				9440	case 0:
				9441	for shift := uint(0); ; shift += 7 {
				9442	if shift >= 64 {
				9443	return 0, ErrIntOverflowGenerated
				9444	}
				9445	if iNdEx >= l {
				9446	return 0, io.ErrUnexpectedEOF
				9447	}
				9448	iNdEx++
				9449	if dAtA[iNdEx-1] < 0x80 {
				9450	break
				9451	}
				9452	}
				9453	return iNdEx, nil
				9454	case 1:
				9455	iNdEx += 8
				9456	return iNdEx, nil
				9457	case 2:
				9458	var length int
				9459	for shift := uint(0); ; shift += 7 {
				9460	if shift >= 64 {
				9461	return 0, ErrIntOverflowGenerated
				9462	}
				9463	if iNdEx >= l {
				9464	return 0, io.ErrUnexpectedEOF
				9465	}
				9466	b := dAtA[iNdEx]
				9467	iNdEx++
				9468	length \|= (int(b) & 0x7F) << shift
				9469	if b < 0x80 {
				9470	break
				9471	}
				9472	}
				9473	iNdEx += length
				9474	if length < 0 {
				9475	return 0, ErrInvalidLengthGenerated
				9476	}
				9477	return iNdEx, nil
				9478	case 3:
				9479	for {
				9480	var innerWire uint64
				9481	var start int = iNdEx
				9482	for shift := uint(0); ; shift += 7 {
				9483	if shift >= 64 {
				9484	return 0, ErrIntOverflowGenerated
				9485	}
				9486	if iNdEx >= l {
				9487	return 0, io.ErrUnexpectedEOF
				9488	}
				9489	b := dAtA[iNdEx]
				9490	iNdEx++
				9491	innerWire \|= (uint64(b) & 0x7F) << shift
				9492	if b < 0x80 {
				9493	break
				9494	}
				9495	}
				9496	innerWireType := int(innerWire & 0x7)
				9497	if innerWireType == 4 {
				9498	break
				9499	}
				9500	next, err := skipGenerated(dAtA[start:])
				9501	if err != nil {
				9502	return 0, err
				9503	}
				9504	iNdEx = start + next
				9505	}
				9506	return iNdEx, nil
				9507	case 4:
				9508	return iNdEx, nil
				9509	case 5:
				9510	iNdEx += 4
				9511	return iNdEx, nil
				9512	default:
				9513	return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
				9514	}
				9515	}
				9516	panic("unreachable")
				9517	}
				9518
				9519	var (
				9520	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
				9521	ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
				9522	)
				9523
				9524	func init() {
				9525	proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto", fileDescriptorGenerated)
				9526	}
				9527
				9528	var fileDescriptorGenerated = []byte{
David Bainbridge	8697152	2019-09-26 22:09:39 +0000	[diff] [blame^]	9529	// 2820 bytes of a gzipped FileDescriptorProto
				9530	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x1a, 0xcf, 0x6f, 0x1c, 0x57,
				9531	0xd9, 0xb3, 0xeb, 0x5d, 0xef, 0x7e, 0xeb, 0x4d, 0xec, 0x97, 0x04, 0xb6, 0x46, 0x78, 0xdd, 0x29,
				9532	0xaa, 0x52, 0x48, 0xd7, 0x4d, 0x4a, 0xab, 0x90, 0xd2, 0x82, 0xd7, 0x76, 0x52, 0xd3, 0xb8, 0xb1,
				9533	0x9e, 0x93, 0x20, 0x42, 0x84, 0x3a, 0xde, 0x79, 0x5e, 0x0f, 0x9e, 0x9d, 0x99, 0xbe, 0x37, 0xeb,
				9534	0xc4, 0x70, 0xa0, 0x07, 0x10, 0x20, 0x41, 0xd5, 0x23, 0x27, 0xd4, 0x0a, 0xfe, 0x02, 0x4e, 0x9c,
				9535	0x38, 0x55, 0xa2, 0x17, 0xa4, 0x4a, 0x5c, 0x2a, 0x81, 0x56, 0xad, 0x41, 0x82, 0x1b, 0xe2, 0xea,
				9536	0x13, 0x7a, 0xbf, 0x66, 0xde, 0xec, 0x7a, 0xe3, 0x59, 0x52, 0x2a, 0x4e, 0x3b, 0xf3, 0xfd, 0x7e,
				9537	0xef, 0x7d, 0xef, 0xfb, 0x35, 0x0b, 0x9b, 0xfb, 0x57, 0x59, 0xcb, 0x0b, 0x97, 0xf7, 0xfb, 0x3b,
				9538	0x84, 0x06, 0x24, 0x26, 0x6c, 0xf9, 0x80, 0x04, 0x6e, 0x48, 0x97, 0x15, 0xc2, 0x89, 0xbc, 0x9e,
				9539	0xd3, 0xd9, 0xf3, 0x02, 0x42, 0x0f, 0x97, 0xa3, 0xfd, 0x2e, 0x07, 0xb0, 0xe5, 0x1e, 0x89, 0x9d,
				9540	0xe5, 0x83, 0xcb, 0xcb, 0x5d, 0x12, 0x10, 0xea, 0xc4, 0xc4, 0x6d, 0x45, 0x34, 0x8c, 0x43, 0xf4,
				9541	0x25, 0xc9, 0xd5, 0x32, 0xb9, 0x5a, 0xd1, 0x7e, 0x97, 0x03, 0x58, 0x8b, 0x73, 0xb5, 0x0e, 0x2e,
				9542	0x2f, 0x3c, 0xdb, 0xf5, 0xe2, 0xbd, 0xfe, 0x4e, 0xab, 0x13, 0xf6, 0x96, 0xbb, 0x61, 0x37, 0x5c,
				9543	0x16, 0xcc, 0x3b, 0xfd, 0x5d, 0xf1, 0x26, 0x5e, 0xc4, 0x93, 0x14, 0xba, 0x30, 0xd6, 0x14, 0xda,
				9544	0x0f, 0x62, 0xaf, 0x47, 0x86, 0xad, 0x58, 0x78, 0xf1, 0x34, 0x06, 0xd6, 0xd9, 0x23, 0x3d, 0x67,
				9545	0x98, 0xcf, 0xfe, 0x63, 0x11, 0x2a, 0x2b, 0x5b, 0x1b, 0x37, 0x68, 0xd8, 0x8f, 0xd0, 0x12, 0x4c,
				9546	0x07, 0x4e, 0x8f, 0x34, 0xac, 0x25, 0xeb, 0x62, 0xb5, 0x3d, 0xfb, 0xc1, 0xa0, 0x39, 0x75, 0x34,
				9547	0x68, 0x4e, 0xbf, 0xee, 0xf4, 0x08, 0x16, 0x18, 0xe4, 0x43, 0xe5, 0x80, 0x50, 0xe6, 0x85, 0x01,
				9548	0x6b, 0x14, 0x96, 0x8a, 0x17, 0x6b, 0x57, 0x5e, 0x69, 0xe5, 0x59, 0x7f, 0x4b, 0x28, 0xb8, 0x2b,
				9549	0x59, 0xaf, 0x87, 0x74, 0xcd, 0x63, 0x9d, 0xf0, 0x80, 0xd0, 0xc3, 0xf6, 0x9c, 0xd2, 0x52, 0x51,
				9550	0x48, 0x86, 0x13, 0x0d, 0xe8, 0xc7, 0x16, 0xcc, 0x45, 0x94, 0xec, 0x12, 0x4a, 0x89, 0xab, 0xf0,
				9551	0x8d, 0xe2, 0x92, 0xf5, 0x29, 0xa8, 0x6d, 0x28, 0xb5, 0x73, 0x5b, 0x43, 0xf2, 0xf1, 0x88, 0x46,
				9552	0xf4, 0x1b, 0x0b, 0x16, 0x18, 0xa1, 0x07, 0x84, 0xae, 0xb8, 0x2e, 0x25, 0x8c, 0xb5, 0x0f, 0x57,
				9553	0x7d, 0x8f, 0x04, 0xf1, 0xea, 0xc6, 0x1a, 0x66, 0x8d, 0x69, 0xb1, 0x0f, 0xdf, 0xc8, 0x67, 0xd0,
				9554	0xf6, 0x38, 0x39, 0x6d, 0x5b, 0x59, 0xb4, 0x30, 0x96, 0x84, 0xe1, 0x47, 0x98, 0x61, 0xef, 0xc2,
				9555	0xac, 0x3e, 0xc8, 0x9b, 0x1e, 0x8b, 0xd1, 0x5d, 0x28, 0x77, 0xf9, 0x0b, 0x6b, 0x58, 0xc2, 0xc0,
				9556	0x56, 0x3e, 0x03, 0xb5, 0x8c, 0xf6, 0x19, 0x65, 0x4f, 0x59, 0xbc, 0x32, 0xac, 0xa4, 0xd9, 0x3f,
				9557	0x9f, 0x86, 0xda, 0xca, 0xd6, 0x06, 0x26, 0x2c, 0xec, 0xd3, 0x0e, 0xc9, 0xe1, 0x34, 0x57, 0x00,
				9558	0xf8, 0x2f, 0x8b, 0x9c, 0x0e, 0x71, 0x1b, 0x85, 0x25, 0xeb, 0x62, 0xa5, 0x8d, 0x14, 0x1d, 0xbc,
				9559	0x9e, 0x60, 0xb0, 0x41, 0xc5, 0xa5, 0xee, 0x7b, 0x81, 0x2b, 0x4e, 0xdb, 0x90, 0xfa, 0x9a, 0x17,
				9560	0xb8, 0x58, 0x60, 0xd0, 0x4d, 0x28, 0x1d, 0x10, 0xba, 0xc3, 0xf7, 0x9f, 0x3b, 0xc4, 0x57, 0xf2,
				9561	0x2d, 0xef, 0x2e, 0x67, 0x69, 0x57, 0x8f, 0x06, 0xcd, 0x92, 0x78, 0xc4, 0x52, 0x08, 0x6a, 0x01,
				9562	0xb0, 0xbd, 0x90, 0xc6, 0xc2, 0x9c, 0x46, 0x69, 0xa9, 0x78, 0xb1, 0xda, 0x3e, 0xc3, 0xed, 0xdb,
				9563	0x4e, 0xa0, 0xd8, 0xa0, 0x40, 0x57, 0x61, 0x96, 0x79, 0x41, 0xb7, 0xef, 0x3b, 0x94, 0x03, 0x1a,
				9564	0x65, 0x61, 0xe7, 0x79, 0x65, 0xe7, 0xec, 0xb6, 0x81, 0xc3, 0x19, 0x4a, 0xae, 0xa9, 0xe3, 0xc4,
				9565	0xa4, 0x1b, 0x52, 0x8f, 0xb0, 0xc6, 0x4c, 0xaa, 0x69, 0x35, 0x81, 0x62, 0x83, 0x02, 0x3d, 0x05,
				9566	0x25, 0xb1, 0xf3, 0x8d, 0x8a, 0x50, 0x51, 0x57, 0x2a, 0x4a, 0xe2, 0x58, 0xb0, 0xc4, 0xa1, 0x67,
				9567	0x60, 0x46, 0xdd, 0x9a, 0x46, 0x55, 0x90, 0x9d, 0x55, 0x64, 0x33, 0xda, 0xad, 0x35, 0x1e, 0x7d,
				9568	0x0b, 0x10, 0x8b, 0x43, 0xea, 0x74, 0x89, 0x42, 0xbd, 0xea, 0xb0, 0xbd, 0x06, 0x08, 0xae, 0x05,
				9569	0xc5, 0x85, 0xb6, 0x47, 0x28, 0xf0, 0x09, 0x5c, 0xf6, 0xef, 0x2c, 0x38, 0x6b, 0xf8, 0x82, 0xf0,
				9570	0xbb, 0xab, 0x30, 0xdb, 0x35, 0x6e, 0x9d, 0xf2, 0x8b, 0x64, 0x67, 0xcc, 0x1b, 0x89, 0x33, 0x94,
				9571	0x88, 0x40, 0x95, 0x2a, 0x49, 0x3a, 0xba, 0x5c, 0xce, 0xed, 0xb4, 0xda, 0x86, 0x54, 0x93, 0x01,
				9572	0x64, 0x38, 0x95, 0x6c, 0xff, 0xc3, 0x12, 0x0e, 0xac, 0xe3, 0x0d, 0xba, 0x68, 0xc4, 0x34, 0x4b,
				9573	0x1c, 0xc7, 0xec, 0x98, 0x78, 0x74, 0x4a, 0x20, 0x28, 0xfc, 0x5f, 0x04, 0x82, 0x6b, 0x95, 0x5f,
				9574	0xbd, 0xdb, 0x9c, 0x7a, 0xeb, 0xaf, 0x4b, 0x53, 0x76, 0x0f, 0xea, 0xab, 0x94, 0x38, 0x31, 0xb9,
				9575	0x15, 0xc5, 0x62, 0x01, 0x36, 0x94, 0x5d, 0x7a, 0x88, 0xfb, 0x81, 0x5a, 0x28, 0xf0, 0xfb, 0xbd,
				9576	0x26, 0x20, 0x58, 0x61, 0xf8, 0xf9, 0xed, 0x7a, 0xc4, 0x77, 0x37, 0x9d, 0xc0, 0xe9, 0x12, 0xaa,
				9577	0x6e, 0x60, 0xb2, 0xab, 0xd7, 0x0d, 0x1c, 0xce, 0x50, 0xda, 0x3f, 0x2d, 0x42, 0x7d, 0x8d, 0xf8,
				9578	0x24, 0xd5, 0x77, 0x1d, 0x50, 0x97, 0x3a, 0x1d, 0xb2, 0x45, 0xa8, 0x17, 0xba, 0xdb, 0xa4, 0x13,
				9579	0x06, 0x2e, 0x13, 0x1e, 0x51, 0x6c, 0x7f, 0x8e, 0xfb, 0xd9, 0x8d, 0x11, 0x2c, 0x3e, 0x81, 0x03,
				9580	0xf9, 0x50, 0x8f, 0xa8, 0x78, 0xf6, 0x62, 0x95, 0x7b, 0xf8, 0x9d, 0x7f, 0x3e, 0xdf, 0x56, 0x6f,
				9581	0x99, 0xac, 0xed, 0xf9, 0xa3, 0x41, 0xb3, 0x9e, 0x01, 0xe1, 0xac, 0x70, 0xf4, 0x4d, 0x98, 0x0b,
				9582	0x69, 0xb4, 0xe7, 0x04, 0x6b, 0x24, 0x22, 0x81, 0x4b, 0x82, 0x98, 0x89, 0x5d, 0xa8, 0xb4, 0xcf,
				9583	0xf3, 0x8c, 0x71, 0x6b, 0x08, 0x87, 0x47, 0xa8, 0xd1, 0x3d, 0x98, 0x8f, 0x68, 0x18, 0x39, 0x5d,
				9584	0x87, 0x4b, 0xdc, 0x0a, 0x7d, 0xaf, 0x73, 0x28, 0xe2, 0x54, 0xb5, 0x7d, 0xe9, 0x68, 0xd0, 0x9c,
				9585	0xdf, 0x1a, 0x46, 0x1e, 0x0f, 0x9a, 0xe7, 0xc4, 0xd6, 0x71, 0x48, 0x8a, 0xc4, 0xa3, 0x62, 0x8c,
				9586	0x33, 0x2c, 0x8d, 0x3b, 0x43, 0x7b, 0x03, 0x2a, 0x6b, 0x7d, 0x2a, 0xb8, 0xd0, 0xcb, 0x50, 0x71,
				9587	0xd5, 0xb3, 0xda, 0xf9, 0x27, 0x75, 0xca, 0xd5, 0x34, 0xc7, 0x83, 0x66, 0x9d, 0x17, 0x09, 0x2d,
				9588	0x0d, 0xc0, 0x09, 0x8b, 0x7d, 0x1f, 0xea, 0xeb, 0x0f, 0xa3, 0x90, 0xc6, 0xfa, 0x4c, 0x9f, 0x86,
				9589	0x32, 0x11, 0x00, 0x21, 0xad, 0x92, 0xe6, 0x09, 0x49, 0x86, 0x15, 0x96, 0xc7, 0x2d, 0xf2, 0xd0,
				9590	0xe9, 0xc4, 0x2a, 0xe0, 0x27, 0x71, 0x6b, 0x9d, 0x03, 0xb1, 0xc4, 0xd9, 0xef, 0x5b, 0x50, 0x16,
				9591	0x1e, 0xc5, 0xd0, 0x6d, 0x28, 0xf6, 0x9c, 0x48, 0x25, 0xab, 0x17, 0xf2, 0x9d, 0xac, 0x64, 0x6d,
				9592	0x6d, 0x3a, 0xd1, 0x7a, 0x10, 0xd3, 0xc3, 0x76, 0x4d, 0x29, 0x29, 0x6e, 0x3a, 0x11, 0xe6, 0xe2,
				9593	0x16, 0x5c, 0xa8, 0x68, 0x2c, 0x9a, 0x83, 0xe2, 0x3e, 0x39, 0x94, 0x01, 0x09, 0xf3, 0x47, 0xd4,
				9594	0x86, 0xd2, 0x81, 0xe3, 0xf7, 0x89, 0xf2, 0xa7, 0x4b, 0x93, 0x68, 0xc5, 0x92, 0xf5, 0x5a, 0xe1,
				9595	0xaa, 0x65, 0xdf, 0x02, 0xb8, 0x41, 0x92, 0x1d, 0x5a, 0x81, 0xb3, 0x3a, 0xda, 0x64, 0x83, 0xe0,
				9596	0xe7, 0x95, 0x79, 0x67, 0x71, 0x16, 0x8d, 0x87, 0xe9, 0xed, 0xfb, 0x50, 0x15, 0x81, 0x92, 0xe7,
				9597	0xbb, 0x34, 0x03, 0x58, 0x8f, 0xc8, 0x00, 0x3a, 0x61, 0x16, 0xc6, 0x25, 0x4c, 0x23, 0x2e, 0xf8,
				9598	0x50, 0x97, 0xbc, 0x3a, 0x87, 0xe7, 0xd2, 0x70, 0x09, 0x2a, 0xda, 0x4c, 0xa5, 0x25, 0xa9, 0xdd,
				9599	0xb4, 0x20, 0x9c, 0x50, 0x18, 0xda, 0xf6, 0x20, 0x13, 0xf4, 0xf3, 0x29, 0x33, 0x12, 0x5a, 0xe1,
				9600	0xd1, 0x09, 0xcd, 0xd0, 0xf4, 0x23, 0x68, 0x8c, 0x2b, 0xf8, 0x1e, 0x23, 0x2d, 0xe5, 0x37, 0xc5,
				9601	0x7e, 0xdb, 0x82, 0x39, 0x53, 0x52, 0xfe, 0xe3, 0xcb, 0xaf, 0xe4, 0xf4, 0xd2, 0xc8, 0xd8, 0x91,
				9602	0x5f, 0x5b, 0x70, 0x3e, 0xb3, 0xb4, 0x89, 0x4e, 0x7c, 0x02, 0xa3, 0x4c, 0xe7, 0x28, 0x4e, 0xe0,
				9603	0x1c, 0xcb, 0x50, 0xdb, 0x08, 0xbc, 0xd8, 0x73, 0x7c, 0xef, 0x07, 0x84, 0x9e, 0x5e, 0x4c, 0xda,
				9604	0x7f, 0xb0, 0x60, 0xd6, 0xe0, 0x60, 0xe8, 0x3e, 0xcc, 0xf0, 0xb8, 0xeb, 0x05, 0x5d, 0x15, 0x3b,
				9605	0x72, 0xd6, 0x0c, 0x86, 0x90, 0x74, 0x5d, 0x5b, 0x52, 0x12, 0xd6, 0x22, 0xd1, 0x16, 0x94, 0x29,
				9606	0x61, 0x7d, 0x3f, 0x9e, 0x2c, 0x44, 0x6c, 0xc7, 0x4e, 0xdc, 0x67, 0x32, 0x36, 0x63, 0xc1, 0x8f,
				9607	0x95, 0x1c, 0xfb, 0xcf, 0x05, 0xa8, 0xdf, 0x74, 0x76, 0x88, 0xbf, 0x4d, 0x7c, 0xd2, 0x89, 0x43,
				9608	0x8a, 0x7e, 0x08, 0xb5, 0x9e, 0x13, 0x77, 0xf6, 0x04, 0x54, 0x97, 0xeb, 0x6b, 0xf9, 0x14, 0x65,
				9609	0x24, 0xb5, 0x36, 0x53, 0x31, 0x32, 0x20, 0x9e, 0x53, 0x0b, 0xab, 0x19, 0x18, 0x6c, 0x6a, 0x13,
				9610	0x3d, 0x96, 0x78, 0x5f, 0x7f, 0x18, 0xf1, 0x5a, 0x62, 0xf2, 0xd6, 0x2e, 0x63, 0x02, 0x26, 0x6f,
				9611	0xf6, 0x3d, 0x4a, 0x7a, 0x24, 0x88, 0xd3, 0x1e, 0x6b, 0x73, 0x48, 0x3e, 0x1e, 0xd1, 0xb8, 0xf0,
				9612	0x0a, 0xcc, 0x0d, 0x1b, 0x7f, 0x42, 0xbc, 0x3e, 0x6f, 0xc6, 0xeb, 0xaa, 0x19, 0x81, 0x7f, 0x6b,
				9613	0x41, 0x63, 0x9c, 0x21, 0xe8, 0x8b, 0x86, 0xa0, 0x34, 0x47, 0xbc, 0x46, 0x0e, 0xa5, 0xd4, 0x75,
				9614	0xa8, 0x84, 0x11, 0xef, 0x8a, 0x43, 0xaa, 0xfc, 0xfc, 0x19, 0xed, 0xbb, 0xb7, 0x14, 0xfc, 0x78,
				9615	0xd0, 0xbc, 0x90, 0x11, 0xaf, 0x11, 0x38, 0x61, 0xe5, 0x89, 0x59, 0xd8, 0xc3, 0x8b, 0x85, 0x24,
				9616	0x31, 0xdf, 0x15, 0x10, 0xac, 0x30, 0xf6, 0xef, 0x2d, 0x98, 0x16, 0x55, 0xf2, 0x7d, 0xa8, 0xf0,
				9617	0xfd, 0x73, 0x9d, 0xd8, 0x11, 0x76, 0xe5, 0xee, 0xcf, 0x38, 0xf7, 0x26, 0x89, 0x9d, 0xf4, 0x7e,
				9618	0x69, 0x08, 0x4e, 0x24, 0x22, 0x0c, 0x25, 0x2f, 0x26, 0x3d, 0x7d, 0x90, 0xcf, 0x8e, 0x15, 0xad,
				9619	0xa6, 0x03, 0x2d, 0xec, 0x3c, 0x58, 0x7f, 0x18, 0x93, 0x80, 0x1f, 0x46, 0x1a, 0x0c, 0x36, 0xb8,
				9620	0x0c, 0x2c, 0x45, 0xd9, 0xff, 0xb6, 0x20, 0x51, 0xc5, 0xaf, 0x3b, 0x23, 0xfe, 0xee, 0x4d, 0x2f,
				9621	0xd8, 0x57, 0xdb, 0x9a, 0x98, 0xb3, 0xad, 0xe0, 0x38, 0xa1, 0x38, 0x29, 0x21, 0x16, 0x26, 0x4b,
				9622	0x88, 0x5c, 0x61, 0x27, 0x0c, 0x62, 0x2f, 0xe8, 0x8f, 0xc4, 0x97, 0x55, 0x05, 0xc7, 0x09, 0x05,
				9623	0xaf, 0x3b, 0x29, 0xe9, 0x39, 0x5e, 0xe0, 0x05, 0x5d, 0xbe, 0x88, 0xd5, 0xb0, 0x1f, 0xc4, 0xa2,
				9624	0x00, 0x53, 0x75, 0x27, 0x1e, 0xc1, 0xe2, 0x13, 0x38, 0xec, 0x3f, 0x15, 0xa1, 0xc6, 0xd7, 0xac,
				9625	0x33, 0xfb, 0x4b, 0x50, 0xf7, 0x4d, 0x2f, 0x50, 0x6b, 0xbf, 0xa0, 0x4c, 0xc9, 0xde, 0x6b, 0x9c,
				9626	0xa5, 0xe5, 0xcc, 0xa2, 0x5c, 0x4e, 0x98, 0x0b, 0x59, 0xe6, 0xeb, 0x26, 0x12, 0x67, 0x69, 0x79,
				9627	0xbc, 0x7e, 0xc0, 0xef, 0x87, 0x2a, 0x44, 0x93, 0x23, 0xfa, 0x36, 0x07, 0x62, 0x89, 0x3b, 0x69,
				9628	0x9f, 0xa7, 0x27, 0xdc, 0xe7, 0x6b, 0x70, 0x86, 0x3b, 0x44, 0xd8, 0x8f, 0x75, 0xb5, 0x5e, 0x12,
				9629	0xbb, 0x86, 0x8e, 0x06, 0xcd, 0x33, 0xb7, 0x33, 0x18, 0x3c, 0x44, 0xc9, 0x6d, 0xf4, 0xbd, 0x9e,
				9630	0x17, 0x37, 0x66, 0x04, 0x4b, 0x62, 0xe3, 0x4d, 0x0e, 0xc4, 0x12, 0x97, 0x39, 0xc8, 0xca, 0xa9,
				9631	0x07, 0xb9, 0x09, 0xe7, 0x1c, 0xdf, 0x0f, 0x1f, 0x88, 0x65, 0xb6, 0xc3, 0x70, 0xbf, 0xe7, 0xd0,
				9632	0x7d, 0x26, 0x7a, 0xdc, 0x4a, 0xfb, 0x0b, 0x8a, 0xf1, 0xdc, 0xca, 0x28, 0x09, 0x3e, 0x89, 0xcf,
				9633	0xfe, 0x67, 0x01, 0x90, 0xec, 0x56, 0x5c, 0x59, 0xc4, 0xc9, 0x40, 0xf3, 0x0c, 0xcc, 0xf4, 0x54,
				9634	0xb7, 0x63, 0x65, 0xf3, 0x9c, 0x6e, 0x74, 0x34, 0x1e, 0x6d, 0x42, 0x55, 0x5e, 0xf8, 0xd4, 0x89,
				9635	0x97, 0x15, 0x71, 0xf5, 0x96, 0x46, 0x1c, 0x0f, 0x9a, 0x0b, 0x19, 0x35, 0x09, 0xe6, 0xf6, 0x61,
				9636	0x44, 0x70, 0x2a, 0x01, 0x5d, 0x01, 0x70, 0x22, 0xcf, 0x1c, 0x6d, 0x55, 0xd3, 0xd1, 0x48, 0xda,
				9637	0xa4, 0x62, 0x83, 0x0a, 0xbd, 0x0a, 0xd3, 0x7c, 0xe3, 0xd5, 0xdc, 0xe3, 0xcb, 0xf9, 0xc2, 0x06,
				9638	0x3f, 0xba, 0x76, 0x85, 0xe7, 0x52, 0xfe, 0x84, 0x85, 0x04, 0x74, 0x0f, 0xca, 0xc2, 0xcb, 0xe4,
				9639	0x21, 0x4f, 0x58, 0xff, 0x8a, 0x66, 0x48, 0x15, 0xef, 0xc7, 0xc9, 0x13, 0x56, 0x12, 0xed, 0x37,
				9640	0xa1, 0xba, 0xe9, 0x75, 0x68, 0xc8, 0xd5, 0xf1, 0x0d, 0x66, 0x99, 0xe6, 0x2f, 0xd9, 0x60, 0xed,
				9641	0x4b, 0x1a, 0xcf, 0x9d, 0x28, 0x70, 0x82, 0x50, 0xb6, 0x78, 0xa5, 0xd4, 0x89, 0x5e, 0xe7, 0x40,
				9642	0x2c, 0x71, 0xd7, 0xce, 0xf3, 0xfa, 0xe1, 0x67, 0xef, 0x35, 0xa7, 0xde, 0x79, 0xaf, 0x39, 0xf5,
				9643	0xee, 0x7b, 0xaa, 0x96, 0xf8, 0x7b, 0x0d, 0xe0, 0xd6, 0xce, 0xf7, 0x49, 0x47, 0xc6, 0xa8, 0xd3,
				9644	0x07, 0x53, 0xbc, 0x26, 0x54, 0xf3, 0x50, 0x31, 0xc4, 0x29, 0x0c, 0xd5, 0x84, 0x06, 0x0e, 0x67,
				9645	0x28, 0xd1, 0x32, 0x54, 0x93, 0x61, 0x95, 0x3a, 0xb6, 0x79, 0xed, 0x06, 0xc9, 0x44, 0x0b, 0xa7,
				9646	0x34, 0x99, 0x80, 0x39, 0x7d, 0x6a, 0xc0, 0x6c, 0x43, 0xb1, 0xef, 0xb9, 0xe2, 0x54, 0xaa, 0xed,
				9647	0xe7, 0x74, 0xc2, 0xba, 0xb3, 0xb1, 0x76, 0x3c, 0x68, 0x3e, 0x39, 0x6e, 0xd2, 0x1b, 0x1f, 0x46,
				9648	0x84, 0xb5, 0xee, 0x6c, 0xac, 0x61, 0xce, 0x7c, 0x52, 0x30, 0x28, 0x4f, 0x18, 0x0c, 0xae, 0x00,
				9649	0xa8, 0x55, 0x73, 0x6e, 0x79, 0xab, 0x13, 0xef, 0xbc, 0x91, 0x60, 0xb0, 0x41, 0x85, 0x18, 0xcc,
				9650	0x77, 0x28, 0x91, 0xce, 0xee, 0xf5, 0x08, 0x8b, 0x9d, 0x9e, 0x1c, 0x5d, 0x4d, 0xe6, 0xaa, 0x4f,
				9651	0x28, 0x35, 0xf3, 0xab, 0xc3, 0xc2, 0xf0, 0xa8, 0x7c, 0x14, 0xc2, 0xbc, 0xab, 0xba, 0xe7, 0x54,
				9652	0x69, 0x75, 0x62, 0xa5, 0x17, 0xb8, 0xc2, 0xb5, 0x61, 0x41, 0x78, 0x54, 0x36, 0xfa, 0x1e, 0x2c,
				9653	0x68, 0xe0, 0xe8, 0x08, 0x43, 0x0c, 0xd3, 0x8a, 0xed, 0xc5, 0xa3, 0x41, 0x73, 0x61, 0x6d, 0x2c,
				9654	0x15, 0x7e, 0x84, 0x04, 0xe4, 0x42, 0xd9, 0x97, 0xd5, 0x60, 0x4d, 0x64, 0xf0, 0xaf, 0xe7, 0x5b,
				9655	0x45, 0xea, 0xfd, 0x2d, 0xb3, 0x0a, 0x4c, 0x5a, 0x74, 0x55, 0x00, 0x2a, 0xd9, 0xe8, 0x21, 0xd4,
				9656	0x9c, 0x20, 0x08, 0x63, 0x47, 0x0e, 0x55, 0x66, 0x85, 0xaa, 0x95, 0x89, 0x55, 0xad, 0xa4, 0x32,
				9657	0x86, 0xaa, 0x4e, 0x03, 0x83, 0x4d, 0x55, 0xe8, 0x01, 0x9c, 0x0d, 0x1f, 0x04, 0x84, 0x62, 0xb2,
				9658	0x4b, 0x28, 0x09, 0x3a, 0x84, 0x35, 0xea, 0x42, 0xfb, 0x57, 0x73, 0x6a, 0xcf, 0x30, 0xa7, 0x2e,
				9659	0x9d, 0x85, 0x33, 0x3c, 0xac, 0x05, 0xb5, 0x00, 0x76, 0xbd, 0x40, 0xf5, 0x0e, 0x8d, 0x33, 0xe9,
				9660	0xf4, 0xf5, 0x7a, 0x02, 0xc5, 0x06, 0x05, 0x7a, 0x01, 0x6a, 0x1d, 0xbf, 0xcf, 0x62, 0x22, 0xc7,
				9661	0xbc, 0x67, 0xc5, 0x0d, 0x4a, 0xd6, 0xb7, 0x9a, 0xa2, 0xb0, 0x49, 0x87, 0xf6, 0x60, 0xd6, 0x33,
				9662	0x9a, 0x94, 0xc6, 0x9c, 0xf0, 0xc5, 0x2b, 0x13, 0x77, 0x26, 0xac, 0x3d, 0xc7, 0x23, 0x91, 0x09,
				9663	0xc1, 0x19, 0xc9, 0xa8, 0x0f, 0xf5, 0x9e, 0x99, 0x6a, 0x1a, 0xf3, 0x62, 0x1f, 0xaf, 0xe6, 0x53,
				9664	0x35, 0x9a, 0x0c, 0xd3, 0x7a, 0x24, 0x83, 0xc3, 0x59, 0x2d, 0x0b, 0x5f, 0x83, 0xda, 0x7f, 0x59,
				9665	0xaa, 0xf3, 0x52, 0x7f, 0xd8, 0x63, 0x26, 0x2a, 0xf5, 0xdf, 0x2f, 0xc0, 0x99, 0xec, 0x39, 0x27,
				9666	0x2d, 0xb1, 0x35, 0xf6, 0x6b, 0x81, 0x4e, 0x06, 0xc5, 0xb1, 0xc9, 0x40, 0xc5, 0xdc, 0xe9, 0xc7,
				9667	0x89, 0xb9, 0xd9, 0x74, 0x5e, 0xca, 0x95, 0xce, 0x5b, 0x00, 0xbc, 0xdc, 0xa1, 0xa1, 0xef, 0x13,
				9668	0x2a, 0x42, 0x74, 0x45, 0x7d, 0x0f, 0x48, 0xa0, 0xd8, 0xa0, 0xe0, 0xb5, 0xed, 0x8e, 0x1f, 0x76,
				9669	0xf6, 0xc5, 0x16, 0xe8, 0xf0, 0x22, 0x82, 0x73, 0x45, 0xd6, 0xb6, 0xed, 0x11, 0x2c, 0x3e, 0x81,
				9670	0xc3, 0x3e, 0x84, 0x0b, 0x5b, 0x0e, 0xe5, 0x8e, 0x94, 0x5e, 0x65, 0xd1, 0x3c, 0xbc, 0x31, 0xd2,
				9671	0x9a, 0x3c, 0x37, 0x69, 0x48, 0x48, 0x17, 0x9d, 0xc2, 0xd2, 0xf6, 0xc4, 0xfe, 0x8b, 0x05, 0x4f,
				9672	0x9c, 0xa8, 0xfb, 0x33, 0x68, 0x8d, 0xde, 0xc8, 0xb6, 0x46, 0x2f, 0xe5, 0x1c, 0x21, 0x9f, 0x64,
				9673	0xed, 0x98, 0x46, 0x69, 0x06, 0x4a, 0x5b, 0xbc, 0xec, 0xb4, 0x7f, 0x69, 0xc1, 0xac, 0x78, 0x9a,
				9674	0x64, 0xfc, 0xde, 0x84, 0xd2, 0x6e, 0xa8, 0x47, 0x6c, 0x15, 0xf9, 0xa5, 0xea, 0x3a, 0x07, 0x60,
				9675	0x09, 0x7f, 0x8c, 0xf9, 0xfc, 0xdb, 0x16, 0x64, 0x07, 0xdf, 0xe8, 0x15, 0xe9, 0xf3, 0x56, 0x32,
				9676	0x99, 0x9e, 0xd0, 0xdf, 0x5f, 0x1e, 0xd7, 0xd8, 0x9d, 0xcb, 0x35, 0xe5, 0xbc, 0x04, 0x55, 0x1c,
				9677	0x86, 0xf1, 0x96, 0x13, 0xef, 0x31, 0xbe, 0xf0, 0x88, 0x3f, 0xa8, 0xbd, 0x11, 0x0b, 0x17, 0x18,
				9678	0x2c, 0xe1, 0xf6, 0x2f, 0x2c, 0x78, 0x62, 0xec, 0x27, 0x11, 0x7e, 0xf5, 0x3a, 0xc9, 0x9b, 0x5a,
				9679	0x51, 0xe2, 0x85, 0x29, 0x1d, 0x36, 0xa8, 0x78, 0x47, 0x96, 0xf9, 0x8e, 0x32, 0xdc, 0x91, 0x65,
				9680	0xb4, 0xe1, 0x2c, 0xad, 0xfd, 0xaf, 0x02, 0x94, 0xe5, 0x98, 0xe7, 0x7f, 0xec, 0xb1, 0x4f, 0x43,
				9681	0x99, 0x09, 0x3d, 0xca, 0xbc, 0x24, 0x9b, 0x4b, 0xed, 0x58, 0x61, 0x45, 0x17, 0x43, 0x18, 0x73,
				9682	0xba, 0x3a, 0xca, 0xa5, 0x5d, 0x8c, 0x04, 0x63, 0x8d, 0x47, 0x2f, 0x42, 0x99, 0x12, 0x87, 0x25,
				9683	0xfd, 0xe1, 0xa2, 0x16, 0x89, 0x05, 0xf4, 0x78, 0xd0, 0x9c, 0x55, 0xc2, 0xc5, 0x3b, 0x56, 0xd4,
				9684	0xe8, 0x1e, 0xcc, 0xb8, 0x24, 0x76, 0x3c, 0x5f, 0x77, 0x0c, 0xcf, 0x4f, 0x32, 0x0e, 0x5b, 0x93,
				9685	0xac, 0xed, 0x1a, 0xb7, 0x49, 0xbd, 0x60, 0x2d, 0x90, 0x47, 0xe8, 0x4e, 0xe8, 0xca, 0x2f, 0xa9,
				9686	0xa5, 0x34, 0x42, 0xaf, 0x86, 0x2e, 0xc1, 0x02, 0x63, 0xbf, 0x63, 0x41, 0x4d, 0x4a, 0x5a, 0x75,
				9687	0xfa, 0x8c, 0xa0, 0xcb, 0xc9, 0x2a, 0xe4, 0x71, 0xeb, 0x9a, 0x71, 0x9a, 0x77, 0x59, 0xc7, 0x83,
				9688	0x66, 0x55, 0x90, 0x89, 0x96, 0x4b, 0x2f, 0xc0, 0xd8, 0xa3, 0xc2, 0x29, 0x7b, 0xf4, 0x14, 0x94,
				9689	0xc4, 0xed, 0x51, 0x9b, 0x99, 0xdc, 0x75, 0x71, 0xc1, 0xb0, 0xc4, 0xd9, 0x1f, 0x17, 0xa0, 0x9e,
				9690	0x59, 0x5c, 0x8e, 0xae, 0x23, 0x19, 0xbd, 0x16, 0x72, 0x8c, 0xf3, 0xc7, 0x7f, 0xff, 0xfe, 0x0e,
				9691	0x94, 0x3b, 0x7c, 0x7d, 0xfa, 0x0f, 0x08, 0x97, 0x27, 0x39, 0x0a, 0xb1, 0x33, 0xa9, 0x27, 0x89,
				9692	0x57, 0x86, 0x95, 0x40, 0x74, 0x03, 0xe6, 0x29, 0x89, 0xe9, 0xe1, 0xca, 0x6e, 0x4c, 0xa8, 0x39,
				9693	0x07, 0x28, 0xa5, 0x75, 0x39, 0x1e, 0x26, 0xc0, 0xa3, 0x3c, 0x3a, 0xa7, 0x96, 0x1f, 0x23, 0xa7,
				9694	0xda, 0x3b, 0x30, 0x7b, 0xdb, 0xd9, 0xf1, 0x93, 0x6f, 0x8a, 0x18, 0xea, 0x5e, 0xd0, 0xf1, 0xfb,
				9695	0x2e, 0x91, 0xd1, 0x58, 0x47, 0x2f, 0x7d, 0x69, 0x37, 0x4c, 0xe4, 0xf1, 0xa0, 0x79, 0x2e, 0x03,
				9696	0x90, 0x1f, 0xd1, 0x70, 0x56, 0x84, 0xed, 0xc3, 0xf4, 0x67, 0xd8, 0xa7, 0x7e, 0x17, 0xaa, 0x69,
				9697	0x27, 0xf1, 0x29, 0xab, 0xb4, 0xdf, 0x80, 0x0a, 0xf7, 0x78, 0xdd, 0x01, 0x9f, 0x52, 0x16, 0x65,
				9698	0x0b, 0x96, 0x42, 0x9e, 0x82, 0xc5, 0xee, 0x41, 0xfd, 0x4e, 0xe4, 0x3e, 0xe6, 0x57, 0xe5, 0x42,
				9699	0xee, 0xac, 0x75, 0x05, 0xe4, 0x3f, 0x35, 0x78, 0x82, 0x90, 0x99, 0xdb, 0x48, 0x10, 0x66, 0xe2,
				9700	0x35, 0xbe, 0x2a, 0xfc, 0xc4, 0x02, 0x10, 0xa3, 0x9f, 0xf5, 0x03, 0x12, 0xc4, 0x7c, 0x1f, 0xb8,
				9701	0x53, 0x0d, 0xef, 0x83, 0x88, 0x0c, 0x02, 0x83, 0xee, 0x40, 0x39, 0x94, 0xde, 0x24, 0xc7, 0xfc,
				9702	0x13, 0x4e, 0x4c, 0x93, 0x8b, 0x24, 0xfd, 0x09, 0x2b, 0x61, 0xed, 0x8b, 0x1f, 0x7c, 0xb2, 0x38,
				9703	0xf5, 0xe1, 0x27, 0x8b, 0x53, 0x1f, 0x7d, 0xb2, 0x38, 0xf5, 0xd6, 0xd1, 0xa2, 0xf5, 0xc1, 0xd1,
				9704	0xa2, 0xf5, 0xe1, 0xd1, 0xa2, 0xf5, 0xd1, 0xd1, 0xa2, 0xf5, 0xf1, 0xd1, 0xa2, 0xf5, 0xce, 0xdf,
				9705	0x16, 0xa7, 0xee, 0x15, 0x0e, 0x2e, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xe0, 0x33, 0x2e,
				9706	0x95, 0x26, 0x00, 0x00,
Zack Williams	e940c7a	2019-08-21 14:25:39 -0700	[diff] [blame]	9707	}