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

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