/*
Copyright 2015 The Kubernetes Authors All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// ************************************************************
// DO NOT EDIT.
// THIS FILE IS AUTO-GENERATED BY codecgen.
// ************************************************************

package v1beta1

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	pkg6_intstr "k8s.io/kubernetes/pkg/util/intstr"
	"reflect"
	"runtime"
	pkg5_inf "speter.net/go/exp/math/dec/inf"
	time "time"
)

const (
	// ----- content types ----
	codecSelferC_UTF81234 = 1
	codecSelferC_RAW1234  = 0
	// ----- value types used ----
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey1234    = 2
	codecSelfer_containerMapValue1234  = 3
	codecSelfer_containerMapEnd1234    = 4
	codecSelfer_containerArrayElem1234 = 6
	codecSelfer_containerArrayEnd1234  = 7
)

var (
	codecSelferBitsize1234                         = uint8(reflect.TypeOf(uint(0)).Bits())
	codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
)

type codecSelfer1234 struct{}

func init() {
	if codec1978.GenVersion != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg4_resource.Quantity
		var v1 pkg1_unversioned.TypeMeta
		var v2 pkg2_v1.ObjectMeta
		var v3 pkg3_types.UID
		var v4 pkg6_intstr.IntOrString
		var v5 pkg5_inf.Dec
		var v6 time.Time
		_, _, _, _, _, _, _ = v0, v1, v2, v3, v4, v5, v6
	}
}

func (x *ScaleSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1 := z.EncBinary()
		_ = yym1
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			var yyq2 [1]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			yyq2[0] = x.Replicas != 0
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 0
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq2[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ScaleSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym6 := z.DecBinary()
	_ = yym6
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct7 := r.ContainerType()
		if yyct7 == codecSelferValueTypeMap1234 {
			yyl7 := r.ReadMapStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl7, d)
			}
		} else if yyct7 == codecSelferValueTypeArray1234 {
			yyl7 := r.ReadArrayStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl7, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ScaleSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys8Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys8Slc
	var yyhl8 bool = l >= 0
	for yyj8 := 0; ; yyj8++ {
		if yyhl8 {
			if yyj8 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys8Slc = r.DecodeBytes(yys8Slc, true, true)
		yys8 := string(yys8Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys8 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys8)
		} // end switch yys8
	} // end for yyj8
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ScaleSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ScaleStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym12 := z.EncBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep13 := !z.EncBinary()
			yy2arr13 := z.EncBasicHandle().StructToArray
			var yyq13 [2]bool
			_, _, _ = yysep13, yyq13, yy2arr13
			const yyr13 bool = false
			yyq13[1] = len(x.Selector) != 0
			var yynn13 int
			if yyr13 || yy2arr13 {
				r.EncodeArrayStart(2)
			} else {
				yynn13 = 1
				for _, b := range yyq13 {
					if b {
						yynn13++
					}
				}
				r.EncodeMapStart(yynn13)
				yynn13 = 0
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq13[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym18 := z.EncBinary()
						_ = yym18
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq13[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym19 := z.EncBinary()
						_ = yym19
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ScaleStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym20 := z.DecBinary()
	_ = yym20
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct21 := r.ContainerType()
		if yyct21 == codecSelferValueTypeMap1234 {
			yyl21 := r.ReadMapStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl21, d)
			}
		} else if yyct21 == codecSelferValueTypeArray1234 {
			yyl21 := r.ReadArrayStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl21, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys22Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys22Slc
	var yyhl22 bool = l >= 0
	for yyj22 := 0; ; yyj22++ {
		if yyhl22 {
			if yyj22 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys22Slc = r.DecodeBytes(yys22Slc, true, true)
		yys22 := string(yys22Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys22 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv24 := &x.Selector
				yym25 := z.DecBinary()
				_ = yym25
				if false {
				} else {
					z.F.DecMapStringStringX(yyv24, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys22)
		} // end switch yys22
	} // end for yyj22
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj26 int
	var yyb26 bool
	var yyhl26 bool = l >= 0
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv28 := &x.Selector
		yym29 := z.DecBinary()
		_ = yym29
		if false {
		} else {
			z.F.DecMapStringStringX(yyv28, false, d)
		}
	}
	for {
		yyj26++
		if yyhl26 {
			yyb26 = yyj26 > l
		} else {
			yyb26 = r.CheckBreak()
		}
		if yyb26 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj26-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym30 := z.EncBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep31 := !z.EncBinary()
			yy2arr31 := z.EncBasicHandle().StructToArray
			var yyq31 [5]bool
			_, _, _ = yysep31, yyq31, yy2arr31
			const yyr31 bool = false
			yyq31[0] = x.Kind != ""
			yyq31[1] = x.APIVersion != ""
			yyq31[2] = true
			yyq31[3] = true
			yyq31[4] = true
			var yynn31 int
			if yyr31 || yy2arr31 {
				r.EncodeArrayStart(5)
			} else {
				yynn31 = 0
				for _, b := range yyq31 {
					if b {
						yynn31++
					}
				}
				r.EncodeMapStart(yynn31)
				yynn31 = 0
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[0] {
					yym33 := z.EncBinary()
					_ = yym33
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym34 := z.EncBinary()
					_ = yym34
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[1] {
					yym36 := z.EncBinary()
					_ = yym36
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym37 := z.EncBinary()
					_ = yym37
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[2] {
					yy39 := &x.ObjectMeta
					yy39.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy40 := &x.ObjectMeta
					yy40.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[3] {
					yy42 := &x.Spec
					yy42.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy43 := &x.Spec
					yy43.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[4] {
					yy45 := &x.Status
					yy45.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy46 := &x.Status
					yy46.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Scale) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym47 := z.DecBinary()
	_ = yym47
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct48 := r.ContainerType()
		if yyct48 == codecSelferValueTypeMap1234 {
			yyl48 := r.ReadMapStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl48, d)
			}
		} else if yyct48 == codecSelferValueTypeArray1234 {
			yyl48 := r.ReadArrayStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl48, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys49Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys49Slc
	var yyhl49 bool = l >= 0
	for yyj49 := 0; ; yyj49++ {
		if yyhl49 {
			if yyj49 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys49Slc = r.DecodeBytes(yys49Slc, true, true)
		yys49 := string(yys49Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys49 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj55 int
	var yyb55 bool
	var yyhl55 bool = l >= 0
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv58 := &x.ObjectMeta
		yyv58.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv59 := &x.Spec
		yyv59.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv60 := &x.Status
		yyv60.CodecDecodeSelf(d)
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj55-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicationControllerDummy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym61 := z.EncBinary()
		_ = yym61
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep62 := !z.EncBinary()
			yy2arr62 := z.EncBasicHandle().StructToArray
			var yyq62 [2]bool
			_, _, _ = yysep62, yyq62, yy2arr62
			const yyr62 bool = false
			yyq62[0] = x.Kind != ""
			yyq62[1] = x.APIVersion != ""
			var yynn62 int
			if yyr62 || yy2arr62 {
				r.EncodeArrayStart(2)
			} else {
				yynn62 = 0
				for _, b := range yyq62 {
					if b {
						yynn62++
					}
				}
				r.EncodeMapStart(yynn62)
				yynn62 = 0
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[0] {
					yym64 := z.EncBinary()
					_ = yym64
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym65 := z.EncBinary()
					_ = yym65
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[1] {
					yym67 := z.EncBinary()
					_ = yym67
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym68 := z.EncBinary()
					_ = yym68
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicationControllerDummy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym69 := z.DecBinary()
	_ = yym69
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct70 := r.ContainerType()
		if yyct70 == codecSelferValueTypeMap1234 {
			yyl70 := r.ReadMapStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl70, d)
			}
		} else if yyct70 == codecSelferValueTypeArray1234 {
			yyl70 := r.ReadArrayStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl70, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicationControllerDummy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys71Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys71Slc
	var yyhl71 bool = l >= 0
	for yyj71 := 0; ; yyj71++ {
		if yyhl71 {
			if yyj71 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys71Slc = r.DecodeBytes(yys71Slc, true, true)
		yys71 := string(yys71Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys71 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys71)
		} // end switch yys71
	} // end for yyj71
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicationControllerDummy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj74 int
	var yyb74 bool
	var yyhl74 bool = l >= 0
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj74++
		if yyhl74 {
			yyb74 = yyj74 > l
		} else {
			yyb74 = r.CheckBreak()
		}
		if yyb74 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj74-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym77 := z.EncBinary()
		_ = yym77
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep78 := !z.EncBinary()
			yy2arr78 := z.EncBasicHandle().StructToArray
			var yyq78 [4]bool
			_, _, _ = yysep78, yyq78, yy2arr78
			const yyr78 bool = false
			yyq78[0] = x.Kind != ""
			yyq78[1] = x.Name != ""
			yyq78[2] = x.APIVersion != ""
			yyq78[3] = x.Subresource != ""
			var yynn78 int
			if yyr78 || yy2arr78 {
				r.EncodeArrayStart(4)
			} else {
				yynn78 = 0
				for _, b := range yyq78 {
					if b {
						yynn78++
					}
				}
				r.EncodeMapStart(yynn78)
				yynn78 = 0
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq78[0] {
					yym80 := z.EncBinary()
					_ = yym80
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym81 := z.EncBinary()
					_ = yym81
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq78[1] {
					yym83 := z.EncBinary()
					_ = yym83
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym84 := z.EncBinary()
					_ = yym84
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq78[2] {
					yym86 := z.EncBinary()
					_ = yym86
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym87 := z.EncBinary()
					_ = yym87
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq78[3] {
					yym89 := z.EncBinary()
					_ = yym89
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("subresource"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym90 := z.EncBinary()
					_ = yym90
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SubresourceReference) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym91 := z.DecBinary()
	_ = yym91
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct92 := r.ContainerType()
		if yyct92 == codecSelferValueTypeMap1234 {
			yyl92 := r.ReadMapStart()
			if yyl92 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl92, d)
			}
		} else if yyct92 == codecSelferValueTypeArray1234 {
			yyl92 := r.ReadArrayStart()
			if yyl92 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl92, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SubresourceReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys93Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys93Slc
	var yyhl93 bool = l >= 0
	for yyj93 := 0; ; yyj93++ {
		if yyhl93 {
			if yyj93 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys93Slc = r.DecodeBytes(yys93Slc, true, true)
		yys93 := string(yys93Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys93 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "subresource":
			if r.TryDecodeAsNil() {
				x.Subresource = ""
			} else {
				x.Subresource = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys93)
		} // end switch yys93
	} // end for yyj93
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SubresourceReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj98 int
	var yyb98 bool
	var yyhl98 bool = l >= 0
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Subresource = ""
	} else {
		x.Subresource = string(r.DecodeString())
	}
	for {
		yyj98++
		if yyhl98 {
			yyb98 = yyj98 > l
		} else {
			yyb98 = r.CheckBreak()
		}
		if yyb98 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj98-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym103 := z.EncBinary()
		_ = yym103
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep104 := !z.EncBinary()
			yy2arr104 := z.EncBasicHandle().StructToArray
			var yyq104 [1]bool
			_, _, _ = yysep104, yyq104, yy2arr104
			const yyr104 bool = false
			var yynn104 int
			if yyr104 || yy2arr104 {
				r.EncodeArrayStart(1)
			} else {
				yynn104 = 1
				for _, b := range yyq104 {
					if b {
						yynn104++
					}
				}
				r.EncodeMapStart(yynn104)
				yynn104 = 0
			}
			if yyr104 || yy2arr104 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym106 := z.EncBinary()
				_ = yym106
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("targetPercentage"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym107 := z.EncBinary()
				_ = yym107
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			}
			if yyr104 || yy2arr104 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CPUTargetUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym108 := z.DecBinary()
	_ = yym108
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct109 := r.ContainerType()
		if yyct109 == codecSelferValueTypeMap1234 {
			yyl109 := r.ReadMapStart()
			if yyl109 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl109, d)
			}
		} else if yyct109 == codecSelferValueTypeArray1234 {
			yyl109 := r.ReadArrayStart()
			if yyl109 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl109, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CPUTargetUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys110Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys110Slc
	var yyhl110 bool = l >= 0
	for yyj110 := 0; ; yyj110++ {
		if yyhl110 {
			if yyj110 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys110Slc = r.DecodeBytes(yys110Slc, true, true)
		yys110 := string(yys110Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys110 {
		case "targetPercentage":
			if r.TryDecodeAsNil() {
				x.TargetPercentage = 0
			} else {
				x.TargetPercentage = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys110)
		} // end switch yys110
	} // end for yyj110
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CPUTargetUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj112 int
	var yyb112 bool
	var yyhl112 bool = l >= 0
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetPercentage = 0
	} else {
		x.TargetPercentage = int32(r.DecodeInt(32))
	}
	for {
		yyj112++
		if yyhl112 {
			yyb112 = yyj112 > l
		} else {
			yyb112 = r.CheckBreak()
		}
		if yyb112 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj112-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym114 := z.EncBinary()
		_ = yym114
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep115 := !z.EncBinary()
			yy2arr115 := z.EncBasicHandle().StructToArray
			var yyq115 [4]bool
			_, _, _ = yysep115, yyq115, yy2arr115
			const yyr115 bool = false
			yyq115[1] = x.MinReplicas != nil
			yyq115[3] = x.CPUUtilization != nil
			var yynn115 int
			if yyr115 || yy2arr115 {
				r.EncodeArrayStart(4)
			} else {
				yynn115 = 2
				for _, b := range yyq115 {
					if b {
						yynn115++
					}
				}
				r.EncodeMapStart(yynn115)
				yynn115 = 0
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy117 := &x.ScaleRef
				yy117.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy118 := &x.ScaleRef
				yy118.CodecEncodeSelf(e)
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq115[1] {
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy120 := *x.MinReplicas
						yym121 := z.EncBinary()
						_ = yym121
						if false {
						} else {
							r.EncodeInt(int64(yy120))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq115[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy122 := *x.MinReplicas
						yym123 := z.EncBinary()
						_ = yym123
						if false {
						} else {
							r.EncodeInt(int64(yy122))
						}
					}
				}
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym125 := z.EncBinary()
				_ = yym125
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym126 := z.EncBinary()
				_ = yym126
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq115[3] {
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq115[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("cpuUtilization"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				}
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym128 := z.DecBinary()
	_ = yym128
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct129 := r.ContainerType()
		if yyct129 == codecSelferValueTypeMap1234 {
			yyl129 := r.ReadMapStart()
			if yyl129 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl129, d)
			}
		} else if yyct129 == codecSelferValueTypeArray1234 {
			yyl129 := r.ReadArrayStart()
			if yyl129 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl129, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys130Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys130Slc
	var yyhl130 bool = l >= 0
	for yyj130 := 0; ; yyj130++ {
		if yyhl130 {
			if yyj130 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys130Slc = r.DecodeBytes(yys130Slc, true, true)
		yys130 := string(yys130Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys130 {
		case "scaleRef":
			if r.TryDecodeAsNil() {
				x.ScaleRef = SubresourceReference{}
			} else {
				yyv131 := &x.ScaleRef
				yyv131.CodecDecodeSelf(d)
			}
		case "minReplicas":
			if r.TryDecodeAsNil() {
				if x.MinReplicas != nil {
					x.MinReplicas = nil
				}
			} else {
				if x.MinReplicas == nil {
					x.MinReplicas = new(int32)
				}
				yym133 := z.DecBinary()
				_ = yym133
				if false {
				} else {
					*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int32(r.DecodeInt(32))
			}
		case "cpuUtilization":
			if r.TryDecodeAsNil() {
				if x.CPUUtilization != nil {
					x.CPUUtilization = nil
				}
			} else {
				if x.CPUUtilization == nil {
					x.CPUUtilization = new(CPUTargetUtilization)
				}
				x.CPUUtilization.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys130)
		} // end switch yys130
	} // end for yyj130
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj136 int
	var yyb136 bool
	var yyhl136 bool = l >= 0
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ScaleRef = SubresourceReference{}
	} else {
		yyv137 := &x.ScaleRef
		yyv137.CodecDecodeSelf(d)
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MinReplicas != nil {
			x.MinReplicas = nil
		}
	} else {
		if x.MinReplicas == nil {
			x.MinReplicas = new(int32)
		}
		yym139 := z.DecBinary()
		_ = yym139
		if false {
		} else {
			*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxReplicas = 0
	} else {
		x.MaxReplicas = int32(r.DecodeInt(32))
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CPUUtilization != nil {
			x.CPUUtilization = nil
		}
	} else {
		if x.CPUUtilization == nil {
			x.CPUUtilization = new(CPUTargetUtilization)
		}
		x.CPUUtilization.CodecDecodeSelf(d)
	}
	for {
		yyj136++
		if yyhl136 {
			yyb136 = yyj136 > l
		} else {
			yyb136 = r.CheckBreak()
		}
		if yyb136 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj136-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym142 := z.EncBinary()
		_ = yym142
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep143 := !z.EncBinary()
			yy2arr143 := z.EncBasicHandle().StructToArray
			var yyq143 [5]bool
			_, _, _ = yysep143, yyq143, yy2arr143
			const yyr143 bool = false
			yyq143[0] = x.ObservedGeneration != nil
			yyq143[1] = x.LastScaleTime != nil
			yyq143[4] = x.CurrentCPUUtilizationPercentage != nil
			var yynn143 int
			if yyr143 || yy2arr143 {
				r.EncodeArrayStart(5)
			} else {
				yynn143 = 2
				for _, b := range yyq143 {
					if b {
						yynn143++
					}
				}
				r.EncodeMapStart(yynn143)
				yynn143 = 0
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq143[0] {
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy145 := *x.ObservedGeneration
						yym146 := z.EncBinary()
						_ = yym146
						if false {
						} else {
							r.EncodeInt(int64(yy145))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy147 := *x.ObservedGeneration
						yym148 := z.EncBinary()
						_ = yym148
						if false {
						} else {
							r.EncodeInt(int64(yy147))
						}
					}
				}
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq143[1] {
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym150 := z.EncBinary()
						_ = yym150
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym150 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym150 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym151 := z.EncBinary()
						_ = yym151
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym151 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym151 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				}
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym153 := z.EncBinary()
				_ = yym153
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym154 := z.EncBinary()
				_ = yym154
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym156 := z.EncBinary()
				_ = yym156
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym157 := z.EncBinary()
				_ = yym157
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq143[4] {
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy159 := *x.CurrentCPUUtilizationPercentage
						yym160 := z.EncBinary()
						_ = yym160
						if false {
						} else {
							r.EncodeInt(int64(yy159))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy161 := *x.CurrentCPUUtilizationPercentage
						yym162 := z.EncBinary()
						_ = yym162
						if false {
						} else {
							r.EncodeInt(int64(yy161))
						}
					}
				}
			}
			if yyr143 || yy2arr143 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym163 := z.DecBinary()
	_ = yym163
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct164 := r.ContainerType()
		if yyct164 == codecSelferValueTypeMap1234 {
			yyl164 := r.ReadMapStart()
			if yyl164 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl164, d)
			}
		} else if yyct164 == codecSelferValueTypeArray1234 {
			yyl164 := r.ReadArrayStart()
			if yyl164 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl164, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys165Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys165Slc
	var yyhl165 bool = l >= 0
	for yyj165 := 0; ; yyj165++ {
		if yyhl165 {
			if yyj165 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys165Slc = r.DecodeBytes(yys165Slc, true, true)
		yys165 := string(yys165Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys165 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				if x.ObservedGeneration != nil {
					x.ObservedGeneration = nil
				}
			} else {
				if x.ObservedGeneration == nil {
					x.ObservedGeneration = new(int64)
				}
				yym167 := z.DecBinary()
				_ = yym167
				if false {
				} else {
					*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
				}
			}
		case "lastScaleTime":
			if r.TryDecodeAsNil() {
				if x.LastScaleTime != nil {
					x.LastScaleTime = nil
				}
			} else {
				if x.LastScaleTime == nil {
					x.LastScaleTime = new(pkg1_unversioned.Time)
				}
				yym169 := z.DecBinary()
				_ = yym169
				if false {
				} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
				} else if yym169 {
					z.DecBinaryUnmarshal(x.LastScaleTime)
				} else if !yym169 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.LastScaleTime)
				} else {
					z.DecFallback(x.LastScaleTime, false)
				}
			}
		case "currentReplicas":
			if r.TryDecodeAsNil() {
				x.CurrentReplicas = 0
			} else {
				x.CurrentReplicas = int32(r.DecodeInt(32))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int32(r.DecodeInt(32))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int32)
				}
				yym173 := z.DecBinary()
				_ = yym173
				if false {
				} else {
					*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys165)
		} // end switch yys165
	} // end for yyj165
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj174 int
	var yyb174 bool
	var yyhl174 bool = l >= 0
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ObservedGeneration != nil {
			x.ObservedGeneration = nil
		}
	} else {
		if x.ObservedGeneration == nil {
			x.ObservedGeneration = new(int64)
		}
		yym176 := z.DecBinary()
		_ = yym176
		if false {
		} else {
			*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
		}
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.LastScaleTime != nil {
			x.LastScaleTime = nil
		}
	} else {
		if x.LastScaleTime == nil {
			x.LastScaleTime = new(pkg1_unversioned.Time)
		}
		yym178 := z.DecBinary()
		_ = yym178
		if false {
		} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
		} else if yym178 {
			z.DecBinaryUnmarshal(x.LastScaleTime)
		} else if !yym178 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.LastScaleTime)
		} else {
			z.DecFallback(x.LastScaleTime, false)
		}
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentReplicas = 0
	} else {
		x.CurrentReplicas = int32(r.DecodeInt(32))
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredReplicas = 0
	} else {
		x.DesiredReplicas = int32(r.DecodeInt(32))
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CurrentCPUUtilizationPercentage != nil {
			x.CurrentCPUUtilizationPercentage = nil
		}
	} else {
		if x.CurrentCPUUtilizationPercentage == nil {
			x.CurrentCPUUtilizationPercentage = new(int32)
		}
		yym182 := z.DecBinary()
		_ = yym182
		if false {
		} else {
			*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
		}
	}
	for {
		yyj174++
		if yyhl174 {
			yyb174 = yyj174 > l
		} else {
			yyb174 = r.CheckBreak()
		}
		if yyb174 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj174-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym183 := z.EncBinary()
		_ = yym183
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep184 := !z.EncBinary()
			yy2arr184 := z.EncBasicHandle().StructToArray
			var yyq184 [5]bool
			_, _, _ = yysep184, yyq184, yy2arr184
			const yyr184 bool = false
			yyq184[0] = x.Kind != ""
			yyq184[1] = x.APIVersion != ""
			yyq184[2] = true
			yyq184[3] = true
			yyq184[4] = true
			var yynn184 int
			if yyr184 || yy2arr184 {
				r.EncodeArrayStart(5)
			} else {
				yynn184 = 0
				for _, b := range yyq184 {
					if b {
						yynn184++
					}
				}
				r.EncodeMapStart(yynn184)
				yynn184 = 0
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq184[0] {
					yym186 := z.EncBinary()
					_ = yym186
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq184[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym187 := z.EncBinary()
					_ = yym187
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq184[1] {
					yym189 := z.EncBinary()
					_ = yym189
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq184[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym190 := z.EncBinary()
					_ = yym190
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq184[2] {
					yy192 := &x.ObjectMeta
					yy192.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy193 := &x.ObjectMeta
					yy193.CodecEncodeSelf(e)
				}
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq184[3] {
					yy195 := &x.Spec
					yy195.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy196 := &x.Spec
					yy196.CodecEncodeSelf(e)
				}
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq184[4] {
					yy198 := &x.Status
					yy198.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy199 := &x.Status
					yy199.CodecEncodeSelf(e)
				}
			}
			if yyr184 || yy2arr184 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym200 := z.DecBinary()
	_ = yym200
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct201 := r.ContainerType()
		if yyct201 == codecSelferValueTypeMap1234 {
			yyl201 := r.ReadMapStart()
			if yyl201 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl201, d)
			}
		} else if yyct201 == codecSelferValueTypeArray1234 {
			yyl201 := r.ReadArrayStart()
			if yyl201 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl201, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys202Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys202Slc
	var yyhl202 bool = l >= 0
	for yyj202 := 0; ; yyj202++ {
		if yyhl202 {
			if yyj202 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys202Slc = r.DecodeBytes(yys202Slc, true, true)
		yys202 := string(yys202Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys202 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv205 := &x.ObjectMeta
				yyv205.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = HorizontalPodAutoscalerSpec{}
			} else {
				yyv206 := &x.Spec
				yyv206.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = HorizontalPodAutoscalerStatus{}
			} else {
				yyv207 := &x.Status
				yyv207.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys202)
		} // end switch yys202
	} // end for yyj202
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj208 int
	var yyb208 bool
	var yyhl208 bool = l >= 0
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv211 := &x.ObjectMeta
		yyv211.CodecDecodeSelf(d)
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = HorizontalPodAutoscalerSpec{}
	} else {
		yyv212 := &x.Spec
		yyv212.CodecDecodeSelf(d)
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = HorizontalPodAutoscalerStatus{}
	} else {
		yyv213 := &x.Status
		yyv213.CodecDecodeSelf(d)
	}
	for {
		yyj208++
		if yyhl208 {
			yyb208 = yyj208 > l
		} else {
			yyb208 = r.CheckBreak()
		}
		if yyb208 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj208-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym214 := z.EncBinary()
		_ = yym214
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep215 := !z.EncBinary()
			yy2arr215 := z.EncBasicHandle().StructToArray
			var yyq215 [4]bool
			_, _, _ = yysep215, yyq215, yy2arr215
			const yyr215 bool = false
			yyq215[0] = x.Kind != ""
			yyq215[1] = x.APIVersion != ""
			yyq215[2] = true
			var yynn215 int
			if yyr215 || yy2arr215 {
				r.EncodeArrayStart(4)
			} else {
				yynn215 = 1
				for _, b := range yyq215 {
					if b {
						yynn215++
					}
				}
				r.EncodeMapStart(yynn215)
				yynn215 = 0
			}
			if yyr215 || yy2arr215 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq215[0] {
					yym217 := z.EncBinary()
					_ = yym217
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq215[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym218 := z.EncBinary()
					_ = yym218
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr215 || yy2arr215 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq215[1] {
					yym220 := z.EncBinary()
					_ = yym220
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq215[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym221 := z.EncBinary()
					_ = yym221
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr215 || yy2arr215 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq215[2] {
					yy223 := &x.ListMeta
					yym224 := z.EncBinary()
					_ = yym224
					if false {
					} else if z.HasExtensions() && z.EncExt(yy223) {
					} else {
						z.EncFallback(yy223)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq215[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy225 := &x.ListMeta
					yym226 := z.EncBinary()
					_ = yym226
					if false {
					} else if z.HasExtensions() && z.EncExt(yy225) {
					} else {
						z.EncFallback(yy225)
					}
				}
			}
			if yyr215 || yy2arr215 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym228 := z.EncBinary()
					_ = yym228
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym229 := z.EncBinary()
					_ = yym229
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr215 || yy2arr215 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym230 := z.DecBinary()
	_ = yym230
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct231 := r.ContainerType()
		if yyct231 == codecSelferValueTypeMap1234 {
			yyl231 := r.ReadMapStart()
			if yyl231 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl231, d)
			}
		} else if yyct231 == codecSelferValueTypeArray1234 {
			yyl231 := r.ReadArrayStart()
			if yyl231 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl231, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys232Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys232Slc
	var yyhl232 bool = l >= 0
	for yyj232 := 0; ; yyj232++ {
		if yyhl232 {
			if yyj232 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys232Slc = r.DecodeBytes(yys232Slc, true, true)
		yys232 := string(yys232Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys232 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv235 := &x.ListMeta
				yym236 := z.DecBinary()
				_ = yym236
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv235) {
				} else {
					z.DecFallback(yyv235, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv237 := &x.Items
				yym238 := z.DecBinary()
				_ = yym238
				if false {
				} else {
					h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv237), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys232)
		} // end switch yys232
	} // end for yyj232
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj239 int
	var yyb239 bool
	var yyhl239 bool = l >= 0
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv242 := &x.ListMeta
		yym243 := z.DecBinary()
		_ = yym243
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv242) {
		} else {
			z.DecFallback(yyv242, false)
		}
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv244 := &x.Items
		yym245 := z.DecBinary()
		_ = yym245
		if false {
		} else {
			h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv244), d)
		}
	}
	for {
		yyj239++
		if yyhl239 {
			yyb239 = yyj239 > l
		} else {
			yyb239 = r.CheckBreak()
		}
		if yyb239 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj239-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym246 := z.EncBinary()
		_ = yym246
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep247 := !z.EncBinary()
			yy2arr247 := z.EncBasicHandle().StructToArray
			var yyq247 [5]bool
			_, _, _ = yysep247, yyq247, yy2arr247
			const yyr247 bool = false
			yyq247[0] = x.Kind != ""
			yyq247[1] = x.APIVersion != ""
			yyq247[2] = true
			yyq247[3] = x.Description != ""
			yyq247[4] = len(x.Versions) != 0
			var yynn247 int
			if yyr247 || yy2arr247 {
				r.EncodeArrayStart(5)
			} else {
				yynn247 = 0
				for _, b := range yyq247 {
					if b {
						yynn247++
					}
				}
				r.EncodeMapStart(yynn247)
				yynn247 = 0
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq247[0] {
					yym249 := z.EncBinary()
					_ = yym249
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym250 := z.EncBinary()
					_ = yym250
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq247[1] {
					yym252 := z.EncBinary()
					_ = yym252
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym253 := z.EncBinary()
					_ = yym253
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq247[2] {
					yy255 := &x.ObjectMeta
					yy255.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq247[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy256 := &x.ObjectMeta
					yy256.CodecEncodeSelf(e)
				}
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq247[3] {
					yym258 := z.EncBinary()
					_ = yym258
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym259 := z.EncBinary()
					_ = yym259
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq247[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym261 := z.EncBinary()
						_ = yym261
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq247[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym262 := z.EncBinary()
						_ = yym262
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yyr247 || yy2arr247 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym263 := z.DecBinary()
	_ = yym263
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct264 := r.ContainerType()
		if yyct264 == codecSelferValueTypeMap1234 {
			yyl264 := r.ReadMapStart()
			if yyl264 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl264, d)
			}
		} else if yyct264 == codecSelferValueTypeArray1234 {
			yyl264 := r.ReadArrayStart()
			if yyl264 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl264, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys265Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys265Slc
	var yyhl265 bool = l >= 0
	for yyj265 := 0; ; yyj265++ {
		if yyhl265 {
			if yyj265 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys265Slc = r.DecodeBytes(yys265Slc, true, true)
		yys265 := string(yys265Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys265 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv268 := &x.ObjectMeta
				yyv268.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv270 := &x.Versions
				yym271 := z.DecBinary()
				_ = yym271
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv270), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys265)
		} // end switch yys265
	} // end for yyj265
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj272 int
	var yyb272 bool
	var yyhl272 bool = l >= 0
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv275 := &x.ObjectMeta
		yyv275.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv277 := &x.Versions
		yym278 := z.DecBinary()
		_ = yym278
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv277), d)
		}
	}
	for {
		yyj272++
		if yyhl272 {
			yyb272 = yyj272 > l
		} else {
			yyb272 = r.CheckBreak()
		}
		if yyb272 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj272-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym279 := z.EncBinary()
		_ = yym279
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep280 := !z.EncBinary()
			yy2arr280 := z.EncBasicHandle().StructToArray
			var yyq280 [4]bool
			_, _, _ = yysep280, yyq280, yy2arr280
			const yyr280 bool = false
			yyq280[0] = x.Kind != ""
			yyq280[1] = x.APIVersion != ""
			yyq280[2] = true
			var yynn280 int
			if yyr280 || yy2arr280 {
				r.EncodeArrayStart(4)
			} else {
				yynn280 = 1
				for _, b := range yyq280 {
					if b {
						yynn280++
					}
				}
				r.EncodeMapStart(yynn280)
				yynn280 = 0
			}
			if yyr280 || yy2arr280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq280[0] {
					yym282 := z.EncBinary()
					_ = yym282
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq280[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym283 := z.EncBinary()
					_ = yym283
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr280 || yy2arr280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq280[1] {
					yym285 := z.EncBinary()
					_ = yym285
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq280[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym286 := z.EncBinary()
					_ = yym286
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr280 || yy2arr280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq280[2] {
					yy288 := &x.ListMeta
					yym289 := z.EncBinary()
					_ = yym289
					if false {
					} else if z.HasExtensions() && z.EncExt(yy288) {
					} else {
						z.EncFallback(yy288)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq280[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy290 := &x.ListMeta
					yym291 := z.EncBinary()
					_ = yym291
					if false {
					} else if z.HasExtensions() && z.EncExt(yy290) {
					} else {
						z.EncFallback(yy290)
					}
				}
			}
			if yyr280 || yy2arr280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym293 := z.EncBinary()
					_ = yym293
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yyr280 || yy2arr280 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym295 := z.DecBinary()
	_ = yym295
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct296 := r.ContainerType()
		if yyct296 == codecSelferValueTypeMap1234 {
			yyl296 := r.ReadMapStart()
			if yyl296 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl296, d)
			}
		} else if yyct296 == codecSelferValueTypeArray1234 {
			yyl296 := r.ReadArrayStart()
			if yyl296 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl296, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys297Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys297Slc
	var yyhl297 bool = l >= 0
	for yyj297 := 0; ; yyj297++ {
		if yyhl297 {
			if yyj297 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys297Slc = r.DecodeBytes(yys297Slc, true, true)
		yys297 := string(yys297Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys297 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv300 := &x.ListMeta
				yym301 := z.DecBinary()
				_ = yym301
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv300) {
				} else {
					z.DecFallback(yyv300, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv302 := &x.Items
				yym303 := z.DecBinary()
				_ = yym303
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv302), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys297)
		} // end switch yys297
	} // end for yyj297
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj304 int
	var yyb304 bool
	var yyhl304 bool = l >= 0
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv307 := &x.ListMeta
		yym308 := z.DecBinary()
		_ = yym308
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv307) {
		} else {
			z.DecFallback(yyv307, false)
		}
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv309 := &x.Items
		yym310 := z.DecBinary()
		_ = yym310
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv309), d)
		}
	}
	for {
		yyj304++
		if yyhl304 {
			yyb304 = yyj304 > l
		} else {
			yyb304 = r.CheckBreak()
		}
		if yyb304 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj304-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym311 := z.EncBinary()
		_ = yym311
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep312 := !z.EncBinary()
			yy2arr312 := z.EncBasicHandle().StructToArray
			var yyq312 [2]bool
			_, _, _ = yysep312, yyq312, yy2arr312
			const yyr312 bool = false
			yyq312[0] = x.Name != ""
			yyq312[1] = x.APIGroup != ""
			var yynn312 int
			if yyr312 || yy2arr312 {
				r.EncodeArrayStart(2)
			} else {
				yynn312 = 0
				for _, b := range yyq312 {
					if b {
						yynn312++
					}
				}
				r.EncodeMapStart(yynn312)
				yynn312 = 0
			}
			if yyr312 || yy2arr312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq312[0] {
					yym314 := z.EncBinary()
					_ = yym314
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq312[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym315 := z.EncBinary()
					_ = yym315
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr312 || yy2arr312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq312[1] {
					yym317 := z.EncBinary()
					_ = yym317
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq312[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym318 := z.EncBinary()
					_ = yym318
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				}
			}
			if yyr312 || yy2arr312 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym319 := z.DecBinary()
	_ = yym319
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct320 := r.ContainerType()
		if yyct320 == codecSelferValueTypeMap1234 {
			yyl320 := r.ReadMapStart()
			if yyl320 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl320, d)
			}
		} else if yyct320 == codecSelferValueTypeArray1234 {
			yyl320 := r.ReadArrayStart()
			if yyl320 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl320, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys321Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys321Slc
	var yyhl321 bool = l >= 0
	for yyj321 := 0; ; yyj321++ {
		if yyhl321 {
			if yyj321 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys321Slc = r.DecodeBytes(yys321Slc, true, true)
		yys321 := string(yys321Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys321 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "apiGroup":
			if r.TryDecodeAsNil() {
				x.APIGroup = ""
			} else {
				x.APIGroup = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys321)
		} // end switch yys321
	} // end for yyj321
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj324 int
	var yyb324 bool
	var yyhl324 bool = l >= 0
	yyj324++
	if yyhl324 {
		yyb324 = yyj324 > l
	} else {
		yyb324 = r.CheckBreak()
	}
	if yyb324 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj324++
	if yyhl324 {
		yyb324 = yyj324 > l
	} else {
		yyb324 = r.CheckBreak()
	}
	if yyb324 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIGroup = ""
	} else {
		x.APIGroup = string(r.DecodeString())
	}
	for {
		yyj324++
		if yyhl324 {
			yyb324 = yyj324 > l
		} else {
			yyb324 = r.CheckBreak()
		}
		if yyb324 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj324-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym327 := z.EncBinary()
		_ = yym327
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep328 := !z.EncBinary()
			yy2arr328 := z.EncBasicHandle().StructToArray
			var yyq328 [4]bool
			_, _, _ = yysep328, yyq328, yy2arr328
			const yyr328 bool = false
			yyq328[0] = x.Kind != ""
			yyq328[1] = x.APIVersion != ""
			yyq328[2] = true
			yyq328[3] = len(x.Data) != 0
			var yynn328 int
			if yyr328 || yy2arr328 {
				r.EncodeArrayStart(4)
			} else {
				yynn328 = 0
				for _, b := range yyq328 {
					if b {
						yynn328++
					}
				}
				r.EncodeMapStart(yynn328)
				yynn328 = 0
			}
			if yyr328 || yy2arr328 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq328[0] {
					yym330 := z.EncBinary()
					_ = yym330
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq328[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym331 := z.EncBinary()
					_ = yym331
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr328 || yy2arr328 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq328[1] {
					yym333 := z.EncBinary()
					_ = yym333
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq328[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym334 := z.EncBinary()
					_ = yym334
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr328 || yy2arr328 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq328[2] {
					yy336 := &x.ObjectMeta
					yy336.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq328[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy337 := &x.ObjectMeta
					yy337.CodecEncodeSelf(e)
				}
			}
			if yyr328 || yy2arr328 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq328[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym339 := z.EncBinary()
						_ = yym339
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq328[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym340 := z.EncBinary()
						_ = yym340
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yyr328 || yy2arr328 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym341 := z.DecBinary()
	_ = yym341
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct342 := r.ContainerType()
		if yyct342 == codecSelferValueTypeMap1234 {
			yyl342 := r.ReadMapStart()
			if yyl342 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl342, d)
			}
		} else if yyct342 == codecSelferValueTypeArray1234 {
			yyl342 := r.ReadArrayStart()
			if yyl342 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl342, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys343Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys343Slc
	var yyhl343 bool = l >= 0
	for yyj343 := 0; ; yyj343++ {
		if yyhl343 {
			if yyj343 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys343Slc = r.DecodeBytes(yys343Slc, true, true)
		yys343 := string(yys343Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys343 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv346 := &x.ObjectMeta
				yyv346.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv347 := &x.Data
				yym348 := z.DecBinary()
				_ = yym348
				if false {
				} else {
					*yyv347 = r.DecodeBytes(*(*[]byte)(yyv347), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys343)
		} // end switch yys343
	} // end for yyj343
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj349 int
	var yyb349 bool
	var yyhl349 bool = l >= 0
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv352 := &x.ObjectMeta
		yyv352.CodecDecodeSelf(d)
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv353 := &x.Data
		yym354 := z.DecBinary()
		_ = yym354
		if false {
		} else {
			*yyv353 = r.DecodeBytes(*(*[]byte)(yyv353), false, false)
		}
	}
	for {
		yyj349++
		if yyhl349 {
			yyb349 = yyj349 > l
		} else {
			yyb349 = r.CheckBreak()
		}
		if yyb349 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj349-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym355 := z.EncBinary()
		_ = yym355
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep356 := !z.EncBinary()
			yy2arr356 := z.EncBasicHandle().StructToArray
			var yyq356 [5]bool
			_, _, _ = yysep356, yyq356, yy2arr356
			const yyr356 bool = false
			yyq356[0] = x.Kind != ""
			yyq356[1] = x.APIVersion != ""
			yyq356[2] = true
			yyq356[3] = true
			yyq356[4] = true
			var yynn356 int
			if yyr356 || yy2arr356 {
				r.EncodeArrayStart(5)
			} else {
				yynn356 = 0
				for _, b := range yyq356 {
					if b {
						yynn356++
					}
				}
				r.EncodeMapStart(yynn356)
				yynn356 = 0
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq356[0] {
					yym358 := z.EncBinary()
					_ = yym358
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq356[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym359 := z.EncBinary()
					_ = yym359
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq356[1] {
					yym361 := z.EncBinary()
					_ = yym361
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq356[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym362 := z.EncBinary()
					_ = yym362
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq356[2] {
					yy364 := &x.ObjectMeta
					yy364.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy365 := &x.ObjectMeta
					yy365.CodecEncodeSelf(e)
				}
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq356[3] {
					yy367 := &x.Spec
					yy367.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy368 := &x.Spec
					yy368.CodecEncodeSelf(e)
				}
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq356[4] {
					yy370 := &x.Status
					yy370.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy371 := &x.Status
					yy371.CodecEncodeSelf(e)
				}
			}
			if yyr356 || yy2arr356 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym372 := z.DecBinary()
	_ = yym372
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct373 := r.ContainerType()
		if yyct373 == codecSelferValueTypeMap1234 {
			yyl373 := r.ReadMapStart()
			if yyl373 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl373, d)
			}
		} else if yyct373 == codecSelferValueTypeArray1234 {
			yyl373 := r.ReadArrayStart()
			if yyl373 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl373, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys374Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys374Slc
	var yyhl374 bool = l >= 0
	for yyj374 := 0; ; yyj374++ {
		if yyhl374 {
			if yyj374 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys374Slc = r.DecodeBytes(yys374Slc, true, true)
		yys374 := string(yys374Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys374 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv377 := &x.ObjectMeta
				yyv377.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv378 := &x.Spec
				yyv378.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv379 := &x.Status
				yyv379.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys374)
		} // end switch yys374
	} // end for yyj374
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj380 int
	var yyb380 bool
	var yyhl380 bool = l >= 0
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv383 := &x.ObjectMeta
		yyv383.CodecDecodeSelf(d)
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv384 := &x.Spec
		yyv384.CodecDecodeSelf(d)
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv385 := &x.Status
		yyv385.CodecDecodeSelf(d)
	}
	for {
		yyj380++
		if yyhl380 {
			yyb380 = yyj380 > l
		} else {
			yyb380 = r.CheckBreak()
		}
		if yyb380 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj380-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym386 := z.EncBinary()
		_ = yym386
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep387 := !z.EncBinary()
			yy2arr387 := z.EncBasicHandle().StructToArray
			var yyq387 [5]bool
			_, _, _ = yysep387, yyq387, yy2arr387
			const yyr387 bool = false
			yyq387[0] = x.Replicas != nil
			yyq387[1] = len(x.Selector) != 0
			yyq387[3] = true
			yyq387[4] = x.UniqueLabelKey != nil
			var yynn387 int
			if yyr387 || yy2arr387 {
				r.EncodeArrayStart(5)
			} else {
				yynn387 = 1
				for _, b := range yyq387 {
					if b {
						yynn387++
					}
				}
				r.EncodeMapStart(yynn387)
				yynn387 = 0
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy389 := *x.Replicas
						yym390 := z.EncBinary()
						_ = yym390
						if false {
						} else {
							r.EncodeInt(int64(yy389))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy391 := *x.Replicas
						yym392 := z.EncBinary()
						_ = yym392
						if false {
						} else {
							r.EncodeInt(int64(yy391))
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym394 := z.EncBinary()
						_ = yym394
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym395 := z.EncBinary()
						_ = yym395
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy397 := &x.Template
				yy397.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy398 := &x.Template
				yy398.CodecEncodeSelf(e)
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[3] {
					yy400 := &x.Strategy
					yy400.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy401 := &x.Strategy
					yy401.CodecEncodeSelf(e)
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[4] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy403 := *x.UniqueLabelKey
						yym404 := z.EncBinary()
						_ = yym404
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy403))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy405 := *x.UniqueLabelKey
						yym406 := z.EncBinary()
						_ = yym406
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy405))
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym407 := z.DecBinary()
	_ = yym407
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct408 := r.ContainerType()
		if yyct408 == codecSelferValueTypeMap1234 {
			yyl408 := r.ReadMapStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl408, d)
			}
		} else if yyct408 == codecSelferValueTypeArray1234 {
			yyl408 := r.ReadArrayStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl408, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys409Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys409Slc
	var yyhl409 bool = l >= 0
	for yyj409 := 0; ; yyj409++ {
		if yyhl409 {
			if yyj409 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys409Slc = r.DecodeBytes(yys409Slc, true, true)
		yys409 := string(yys409Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys409 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym411 := z.DecBinary()
				_ = yym411
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv412 := &x.Selector
				yym413 := z.DecBinary()
				_ = yym413
				if false {
				} else {
					z.F.DecMapStringStringX(yyv412, false, d)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv414 := &x.Template
				yyv414.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv415 := &x.Strategy
				yyv415.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				if x.UniqueLabelKey != nil {
					x.UniqueLabelKey = nil
				}
			} else {
				if x.UniqueLabelKey == nil {
					x.UniqueLabelKey = new(string)
				}
				yym417 := z.DecBinary()
				_ = yym417
				if false {
				} else {
					*((*string)(x.UniqueLabelKey)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys409)
		} // end switch yys409
	} // end for yyj409
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj418 int
	var yyb418 bool
	var yyhl418 bool = l >= 0
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym420 := z.DecBinary()
		_ = yym420
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv421 := &x.Selector
		yym422 := z.DecBinary()
		_ = yym422
		if false {
		} else {
			z.F.DecMapStringStringX(yyv421, false, d)
		}
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv423 := &x.Template
		yyv423.CodecDecodeSelf(d)
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv424 := &x.Strategy
		yyv424.CodecDecodeSelf(d)
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym426 := z.DecBinary()
		_ = yym426
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj418++
		if yyhl418 {
			yyb418 = yyj418 > l
		} else {
			yyb418 = r.CheckBreak()
		}
		if yyb418 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj418-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym427 := z.EncBinary()
		_ = yym427
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep428 := !z.EncBinary()
			yy2arr428 := z.EncBasicHandle().StructToArray
			var yyq428 [2]bool
			_, _, _ = yysep428, yyq428, yy2arr428
			const yyr428 bool = false
			yyq428[0] = x.Type != ""
			yyq428[1] = x.RollingUpdate != nil
			var yynn428 int
			if yyr428 || yy2arr428 {
				r.EncodeArrayStart(2)
			} else {
				yynn428 = 0
				for _, b := range yyq428 {
					if b {
						yynn428++
					}
				}
				r.EncodeMapStart(yynn428)
				yynn428 = 0
			}
			if yyr428 || yy2arr428 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq428[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq428[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr428 || yy2arr428 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq428[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq428[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yyr428 || yy2arr428 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym431 := z.DecBinary()
	_ = yym431
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct432 := r.ContainerType()
		if yyct432 == codecSelferValueTypeMap1234 {
			yyl432 := r.ReadMapStart()
			if yyl432 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl432, d)
			}
		} else if yyct432 == codecSelferValueTypeArray1234 {
			yyl432 := r.ReadArrayStart()
			if yyl432 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl432, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys433Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys433Slc
	var yyhl433 bool = l >= 0
	for yyj433 := 0; ; yyj433++ {
		if yyhl433 {
			if yyj433 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys433Slc = r.DecodeBytes(yys433Slc, true, true)
		yys433 := string(yys433Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys433 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = DeploymentStrategyType(r.DecodeString())
			}
		case "rollingUpdate":
			if r.TryDecodeAsNil() {
				if x.RollingUpdate != nil {
					x.RollingUpdate = nil
				}
			} else {
				if x.RollingUpdate == nil {
					x.RollingUpdate = new(RollingUpdateDeployment)
				}
				x.RollingUpdate.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys433)
		} // end switch yys433
	} // end for yyj433
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj436 int
	var yyb436 bool
	var yyhl436 bool = l >= 0
	yyj436++
	if yyhl436 {
		yyb436 = yyj436 > l
	} else {
		yyb436 = r.CheckBreak()
	}
	if yyb436 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj436++
	if yyhl436 {
		yyb436 = yyj436 > l
	} else {
		yyb436 = r.CheckBreak()
	}
	if yyb436 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollingUpdate != nil {
			x.RollingUpdate = nil
		}
	} else {
		if x.RollingUpdate == nil {
			x.RollingUpdate = new(RollingUpdateDeployment)
		}
		x.RollingUpdate.CodecDecodeSelf(d)
	}
	for {
		yyj436++
		if yyhl436 {
			yyb436 = yyj436 > l
		} else {
			yyb436 = r.CheckBreak()
		}
		if yyb436 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj436-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym439 := z.EncBinary()
	_ = yym439
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *DeploymentStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym440 := z.DecBinary()
	_ = yym440
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *RollingUpdateDeployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym441 := z.EncBinary()
		_ = yym441
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep442 := !z.EncBinary()
			yy2arr442 := z.EncBasicHandle().StructToArray
			var yyq442 [3]bool
			_, _, _ = yysep442, yyq442, yy2arr442
			const yyr442 bool = false
			yyq442[0] = x.MaxUnavailable != nil
			yyq442[1] = x.MaxSurge != nil
			yyq442[2] = x.MinReadySeconds != 0
			var yynn442 int
			if yyr442 || yy2arr442 {
				r.EncodeArrayStart(3)
			} else {
				yynn442 = 0
				for _, b := range yyq442 {
					if b {
						yynn442++
					}
				}
				r.EncodeMapStart(yynn442)
				yynn442 = 0
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym444 := z.EncBinary()
						_ = yym444
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym444 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq442[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym445 := z.EncBinary()
						_ = yym445
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym445 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[1] {
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym447 := z.EncBinary()
						_ = yym447
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym447 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq442[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym448 := z.EncBinary()
						_ = yym448
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym448 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[2] {
					yym450 := z.EncBinary()
					_ = yym450
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq442[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym451 := z.EncBinary()
					_ = yym451
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym452 := z.DecBinary()
	_ = yym452
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct453 := r.ContainerType()
		if yyct453 == codecSelferValueTypeMap1234 {
			yyl453 := r.ReadMapStart()
			if yyl453 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl453, d)
			}
		} else if yyct453 == codecSelferValueTypeArray1234 {
			yyl453 := r.ReadArrayStart()
			if yyl453 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl453, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys454Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys454Slc
	var yyhl454 bool = l >= 0
	for yyj454 := 0; ; yyj454++ {
		if yyhl454 {
			if yyj454 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys454Slc = r.DecodeBytes(yys454Slc, true, true)
		yys454 := string(yys454Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys454 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg6_intstr.IntOrString)
				}
				yym456 := z.DecBinary()
				_ = yym456
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym456 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxUnavailable)
				} else {
					z.DecFallback(x.MaxUnavailable, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				if x.MaxSurge != nil {
					x.MaxSurge = nil
				}
			} else {
				if x.MaxSurge == nil {
					x.MaxSurge = new(pkg6_intstr.IntOrString)
				}
				yym458 := z.DecBinary()
				_ = yym458
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
				} else if !yym458 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxSurge)
				} else {
					z.DecFallback(x.MaxSurge, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys454)
		} // end switch yys454
	} // end for yyj454
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj460 int
	var yyb460 bool
	var yyhl460 bool = l >= 0
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_intstr.IntOrString)
		}
		yym462 := z.DecBinary()
		_ = yym462
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym462 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg6_intstr.IntOrString)
		}
		yym464 := z.DecBinary()
		_ = yym464
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym464 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	for {
		yyj460++
		if yyhl460 {
			yyb460 = yyj460 > l
		} else {
			yyb460 = r.CheckBreak()
		}
		if yyb460 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj460-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym466 := z.EncBinary()
		_ = yym466
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep467 := !z.EncBinary()
			yy2arr467 := z.EncBasicHandle().StructToArray
			var yyq467 [2]bool
			_, _, _ = yysep467, yyq467, yy2arr467
			const yyr467 bool = false
			yyq467[0] = x.Replicas != 0
			yyq467[1] = x.UpdatedReplicas != 0
			var yynn467 int
			if yyr467 || yy2arr467 {
				r.EncodeArrayStart(2)
			} else {
				yynn467 = 0
				for _, b := range yyq467 {
					if b {
						yynn467++
					}
				}
				r.EncodeMapStart(yynn467)
				yynn467 = 0
			}
			if yyr467 || yy2arr467 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq467[0] {
					yym469 := z.EncBinary()
					_ = yym469
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq467[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym470 := z.EncBinary()
					_ = yym470
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr467 || yy2arr467 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq467[1] {
					yym472 := z.EncBinary()
					_ = yym472
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq467[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym473 := z.EncBinary()
					_ = yym473
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr467 || yy2arr467 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym474 := z.DecBinary()
	_ = yym474
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct475 := r.ContainerType()
		if yyct475 == codecSelferValueTypeMap1234 {
			yyl475 := r.ReadMapStart()
			if yyl475 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl475, d)
			}
		} else if yyct475 == codecSelferValueTypeArray1234 {
			yyl475 := r.ReadArrayStart()
			if yyl475 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl475, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys476Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys476Slc
	var yyhl476 bool = l >= 0
	for yyj476 := 0; ; yyj476++ {
		if yyhl476 {
			if yyj476 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys476Slc = r.DecodeBytes(yys476Slc, true, true)
		yys476 := string(yys476Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys476 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys476)
		} // end switch yys476
	} // end for yyj476
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj479 int
	var yyb479 bool
	var yyhl479 bool = l >= 0
	yyj479++
	if yyhl479 {
		yyb479 = yyj479 > l
	} else {
		yyb479 = r.CheckBreak()
	}
	if yyb479 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj479++
	if yyhl479 {
		yyb479 = yyj479 > l
	} else {
		yyb479 = r.CheckBreak()
	}
	if yyb479 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int32(r.DecodeInt(32))
	}
	for {
		yyj479++
		if yyhl479 {
			yyb479 = yyj479 > l
		} else {
			yyb479 = r.CheckBreak()
		}
		if yyb479 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj479-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym482 := z.EncBinary()
		_ = yym482
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep483 := !z.EncBinary()
			yy2arr483 := z.EncBasicHandle().StructToArray
			var yyq483 [4]bool
			_, _, _ = yysep483, yyq483, yy2arr483
			const yyr483 bool = false
			yyq483[0] = x.Kind != ""
			yyq483[1] = x.APIVersion != ""
			yyq483[2] = true
			var yynn483 int
			if yyr483 || yy2arr483 {
				r.EncodeArrayStart(4)
			} else {
				yynn483 = 1
				for _, b := range yyq483 {
					if b {
						yynn483++
					}
				}
				r.EncodeMapStart(yynn483)
				yynn483 = 0
			}
			if yyr483 || yy2arr483 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq483[0] {
					yym485 := z.EncBinary()
					_ = yym485
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq483[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym486 := z.EncBinary()
					_ = yym486
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr483 || yy2arr483 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq483[1] {
					yym488 := z.EncBinary()
					_ = yym488
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq483[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym489 := z.EncBinary()
					_ = yym489
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr483 || yy2arr483 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq483[2] {
					yy491 := &x.ListMeta
					yym492 := z.EncBinary()
					_ = yym492
					if false {
					} else if z.HasExtensions() && z.EncExt(yy491) {
					} else {
						z.EncFallback(yy491)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq483[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy493 := &x.ListMeta
					yym494 := z.EncBinary()
					_ = yym494
					if false {
					} else if z.HasExtensions() && z.EncExt(yy493) {
					} else {
						z.EncFallback(yy493)
					}
				}
			}
			if yyr483 || yy2arr483 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym496 := z.EncBinary()
					_ = yym496
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym497 := z.EncBinary()
					_ = yym497
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr483 || yy2arr483 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym498 := z.DecBinary()
	_ = yym498
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct499 := r.ContainerType()
		if yyct499 == codecSelferValueTypeMap1234 {
			yyl499 := r.ReadMapStart()
			if yyl499 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl499, d)
			}
		} else if yyct499 == codecSelferValueTypeArray1234 {
			yyl499 := r.ReadArrayStart()
			if yyl499 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl499, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys500Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys500Slc
	var yyhl500 bool = l >= 0
	for yyj500 := 0; ; yyj500++ {
		if yyhl500 {
			if yyj500 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys500Slc = r.DecodeBytes(yys500Slc, true, true)
		yys500 := string(yys500Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys500 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv503 := &x.ListMeta
				yym504 := z.DecBinary()
				_ = yym504
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv503) {
				} else {
					z.DecFallback(yyv503, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv505 := &x.Items
				yym506 := z.DecBinary()
				_ = yym506
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv505), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys500)
		} // end switch yys500
	} // end for yyj500
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj507 int
	var yyb507 bool
	var yyhl507 bool = l >= 0
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv510 := &x.ListMeta
		yym511 := z.DecBinary()
		_ = yym511
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv510) {
		} else {
			z.DecFallback(yyv510, false)
		}
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv512 := &x.Items
		yym513 := z.DecBinary()
		_ = yym513
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv512), d)
		}
	}
	for {
		yyj507++
		if yyhl507 {
			yyb507 = yyj507 > l
		} else {
			yyb507 = r.CheckBreak()
		}
		if yyb507 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj507-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetUpdateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym514 := z.EncBinary()
		_ = yym514
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep515 := !z.EncBinary()
			yy2arr515 := z.EncBasicHandle().StructToArray
			var yyq515 [2]bool
			_, _, _ = yysep515, yyq515, yy2arr515
			const yyr515 bool = false
			yyq515[0] = x.Type != ""
			yyq515[1] = x.RollingUpdate != nil
			var yynn515 int
			if yyr515 || yy2arr515 {
				r.EncodeArrayStart(2)
			} else {
				yynn515 = 0
				for _, b := range yyq515 {
					if b {
						yynn515++
					}
				}
				r.EncodeMapStart(yynn515)
				yynn515 = 0
			}
			if yyr515 || yy2arr515 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq515[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq515[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr515 || yy2arr515 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq515[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq515[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yyr515 || yy2arr515 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetUpdateStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym518 := z.DecBinary()
	_ = yym518
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct519 := r.ContainerType()
		if yyct519 == codecSelferValueTypeMap1234 {
			yyl519 := r.ReadMapStart()
			if yyl519 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl519, d)
			}
		} else if yyct519 == codecSelferValueTypeArray1234 {
			yyl519 := r.ReadArrayStart()
			if yyl519 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl519, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetUpdateStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys520Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys520Slc
	var yyhl520 bool = l >= 0
	for yyj520 := 0; ; yyj520++ {
		if yyhl520 {
			if yyj520 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys520Slc = r.DecodeBytes(yys520Slc, true, true)
		yys520 := string(yys520Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys520 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = DaemonSetUpdateStrategyType(r.DecodeString())
			}
		case "rollingUpdate":
			if r.TryDecodeAsNil() {
				if x.RollingUpdate != nil {
					x.RollingUpdate = nil
				}
			} else {
				if x.RollingUpdate == nil {
					x.RollingUpdate = new(RollingUpdateDaemonSet)
				}
				x.RollingUpdate.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys520)
		} // end switch yys520
	} // end for yyj520
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetUpdateStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj523 int
	var yyb523 bool
	var yyhl523 bool = l >= 0
	yyj523++
	if yyhl523 {
		yyb523 = yyj523 > l
	} else {
		yyb523 = r.CheckBreak()
	}
	if yyb523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DaemonSetUpdateStrategyType(r.DecodeString())
	}
	yyj523++
	if yyhl523 {
		yyb523 = yyj523 > l
	} else {
		yyb523 = r.CheckBreak()
	}
	if yyb523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollingUpdate != nil {
			x.RollingUpdate = nil
		}
	} else {
		if x.RollingUpdate == nil {
			x.RollingUpdate = new(RollingUpdateDaemonSet)
		}
		x.RollingUpdate.CodecDecodeSelf(d)
	}
	for {
		yyj523++
		if yyhl523 {
			yyb523 = yyj523 > l
		} else {
			yyb523 = r.CheckBreak()
		}
		if yyb523 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj523-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DaemonSetUpdateStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym526 := z.EncBinary()
	_ = yym526
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *DaemonSetUpdateStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym527 := z.DecBinary()
	_ = yym527
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *RollingUpdateDaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym528 := z.EncBinary()
		_ = yym528
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep529 := !z.EncBinary()
			yy2arr529 := z.EncBasicHandle().StructToArray
			var yyq529 [2]bool
			_, _, _ = yysep529, yyq529, yy2arr529
			const yyr529 bool = false
			yyq529[0] = x.MaxUnavailable != nil
			yyq529[1] = x.MinReadySeconds != 0
			var yynn529 int
			if yyr529 || yy2arr529 {
				r.EncodeArrayStart(2)
			} else {
				yynn529 = 0
				for _, b := range yyq529 {
					if b {
						yynn529++
					}
				}
				r.EncodeMapStart(yynn529)
				yynn529 = 0
			}
			if yyr529 || yy2arr529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq529[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym531 := z.EncBinary()
						_ = yym531
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym531 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq529[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym532 := z.EncBinary()
						_ = yym532
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym532 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr529 || yy2arr529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq529[1] {
					yym534 := z.EncBinary()
					_ = yym534
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq529[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym535 := z.EncBinary()
					_ = yym535
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr529 || yy2arr529 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollingUpdateDaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym536 := z.DecBinary()
	_ = yym536
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct537 := r.ContainerType()
		if yyct537 == codecSelferValueTypeMap1234 {
			yyl537 := r.ReadMapStart()
			if yyl537 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl537, d)
			}
		} else if yyct537 == codecSelferValueTypeArray1234 {
			yyl537 := r.ReadArrayStart()
			if yyl537 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl537, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RollingUpdateDaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys538Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys538Slc
	var yyhl538 bool = l >= 0
	for yyj538 := 0; ; yyj538++ {
		if yyhl538 {
			if yyj538 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys538Slc = r.DecodeBytes(yys538Slc, true, true)
		yys538 := string(yys538Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys538 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg6_intstr.IntOrString)
				}
				yym540 := z.DecBinary()
				_ = yym540
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym540 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxUnavailable)
				} else {
					z.DecFallback(x.MaxUnavailable, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys538)
		} // end switch yys538
	} // end for yyj538
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollingUpdateDaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj542 int
	var yyb542 bool
	var yyhl542 bool = l >= 0
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_intstr.IntOrString)
		}
		yym544 := z.DecBinary()
		_ = yym544
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym544 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	for {
		yyj542++
		if yyhl542 {
			yyb542 = yyj542 > l
		} else {
			yyb542 = r.CheckBreak()
		}
		if yyb542 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj542-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym546 := z.EncBinary()
		_ = yym546
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep547 := !z.EncBinary()
			yy2arr547 := z.EncBasicHandle().StructToArray
			var yyq547 [4]bool
			_, _, _ = yysep547, yyq547, yy2arr547
			const yyr547 bool = false
			yyq547[0] = x.Selector != nil
			yyq547[1] = x.Template != nil
			yyq547[2] = true
			yyq547[3] = x.UniqueLabelKey != nil
			var yynn547 int
			if yyr547 || yy2arr547 {
				r.EncodeArrayStart(4)
			} else {
				yynn547 = 0
				for _, b := range yyq547 {
					if b {
						yynn547++
					}
				}
				r.EncodeMapStart(yynn547)
				yynn547 = 0
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[2] {
					yy551 := &x.UpdateStrategy
					yy551.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updateStrategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy552 := &x.UpdateStrategy
					yy552.CodecEncodeSelf(e)
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[3] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy554 := *x.UniqueLabelKey
						yym555 := z.EncBinary()
						_ = yym555
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy554))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy556 := *x.UniqueLabelKey
						yym557 := z.EncBinary()
						_ = yym557
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy556))
						}
					}
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym558 := z.DecBinary()
	_ = yym558
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct559 := r.ContainerType()
		if yyct559 == codecSelferValueTypeMap1234 {
			yyl559 := r.ReadMapStart()
			if yyl559 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl559, d)
			}
		} else if yyct559 == codecSelferValueTypeArray1234 {
			yyl559 := r.ReadArrayStart()
			if yyl559 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl559, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys560Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys560Slc
	var yyhl560 bool = l >= 0
	for yyj560 := 0; ; yyj560++ {
		if yyhl560 {
			if yyj560 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys560Slc = r.DecodeBytes(yys560Slc, true, true)
		yys560 := string(yys560Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys560 {
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				if x.Template != nil {
					x.Template = nil
				}
			} else {
				if x.Template == nil {
					x.Template = new(pkg2_v1.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		case "updateStrategy":
			if r.TryDecodeAsNil() {
				x.UpdateStrategy = DaemonSetUpdateStrategy{}
			} else {
				yyv563 := &x.UpdateStrategy
				yyv563.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				if x.UniqueLabelKey != nil {
					x.UniqueLabelKey = nil
				}
			} else {
				if x.UniqueLabelKey == nil {
					x.UniqueLabelKey = new(string)
				}
				yym565 := z.DecBinary()
				_ = yym565
				if false {
				} else {
					*((*string)(x.UniqueLabelKey)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys560)
		} // end switch yys560
	} // end for yyj560
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj566 int
	var yyb566 bool
	var yyhl566 bool = l >= 0
	yyj566++
	if yyhl566 {
		yyb566 = yyj566 > l
	} else {
		yyb566 = r.CheckBreak()
	}
	if yyb566 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj566++
	if yyhl566 {
		yyb566 = yyj566 > l
	} else {
		yyb566 = r.CheckBreak()
	}
	if yyb566 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_v1.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	yyj566++
	if yyhl566 {
		yyb566 = yyj566 > l
	} else {
		yyb566 = r.CheckBreak()
	}
	if yyb566 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdateStrategy = DaemonSetUpdateStrategy{}
	} else {
		yyv569 := &x.UpdateStrategy
		yyv569.CodecDecodeSelf(d)
	}
	yyj566++
	if yyhl566 {
		yyb566 = yyj566 > l
	} else {
		yyb566 = r.CheckBreak()
	}
	if yyb566 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym571 := z.DecBinary()
		_ = yym571
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj566++
		if yyhl566 {
			yyb566 = yyj566 > l
		} else {
			yyb566 = r.CheckBreak()
		}
		if yyb566 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj566-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym572 := z.EncBinary()
		_ = yym572
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep573 := !z.EncBinary()
			yy2arr573 := z.EncBasicHandle().StructToArray
			var yyq573 [3]bool
			_, _, _ = yysep573, yyq573, yy2arr573
			const yyr573 bool = false
			var yynn573 int
			if yyr573 || yy2arr573 {
				r.EncodeArrayStart(3)
			} else {
				yynn573 = 3
				for _, b := range yyq573 {
					if b {
						yynn573++
					}
				}
				r.EncodeMapStart(yynn573)
				yynn573 = 0
			}
			if yyr573 || yy2arr573 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym575 := z.EncBinary()
				_ = yym575
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym576 := z.EncBinary()
				_ = yym576
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr573 || yy2arr573 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym578 := z.EncBinary()
				_ = yym578
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym579 := z.EncBinary()
				_ = yym579
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr573 || yy2arr573 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym581 := z.EncBinary()
				_ = yym581
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym582 := z.EncBinary()
				_ = yym582
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr573 || yy2arr573 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym583 := z.DecBinary()
	_ = yym583
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct584 := r.ContainerType()
		if yyct584 == codecSelferValueTypeMap1234 {
			yyl584 := r.ReadMapStart()
			if yyl584 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl584, d)
			}
		} else if yyct584 == codecSelferValueTypeArray1234 {
			yyl584 := r.ReadArrayStart()
			if yyl584 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl584, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys585Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys585Slc
	var yyhl585 bool = l >= 0
	for yyj585 := 0; ; yyj585++ {
		if yyhl585 {
			if yyj585 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys585Slc = r.DecodeBytes(yys585Slc, true, true)
		yys585 := string(yys585Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys585 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int32(r.DecodeInt(32))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int32(r.DecodeInt(32))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys585)
		} // end switch yys585
	} // end for yyj585
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj589 int
	var yyb589 bool
	var yyhl589 bool = l >= 0
	yyj589++
	if yyhl589 {
		yyb589 = yyj589 > l
	} else {
		yyb589 = r.CheckBreak()
	}
	if yyb589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj589++
	if yyhl589 {
		yyb589 = yyj589 > l
	} else {
		yyb589 = r.CheckBreak()
	}
	if yyb589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj589++
	if yyhl589 {
		yyb589 = yyj589 > l
	} else {
		yyb589 = r.CheckBreak()
	}
	if yyb589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	for {
		yyj589++
		if yyhl589 {
			yyb589 = yyj589 > l
		} else {
			yyb589 = r.CheckBreak()
		}
		if yyb589 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj589-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym593 := z.EncBinary()
		_ = yym593
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep594 := !z.EncBinary()
			yy2arr594 := z.EncBasicHandle().StructToArray
			var yyq594 [5]bool
			_, _, _ = yysep594, yyq594, yy2arr594
			const yyr594 bool = false
			yyq594[0] = x.Kind != ""
			yyq594[1] = x.APIVersion != ""
			yyq594[2] = true
			yyq594[3] = true
			yyq594[4] = true
			var yynn594 int
			if yyr594 || yy2arr594 {
				r.EncodeArrayStart(5)
			} else {
				yynn594 = 0
				for _, b := range yyq594 {
					if b {
						yynn594++
					}
				}
				r.EncodeMapStart(yynn594)
				yynn594 = 0
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq594[0] {
					yym596 := z.EncBinary()
					_ = yym596
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq594[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym597 := z.EncBinary()
					_ = yym597
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq594[1] {
					yym599 := z.EncBinary()
					_ = yym599
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq594[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym600 := z.EncBinary()
					_ = yym600
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq594[2] {
					yy602 := &x.ObjectMeta
					yy602.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq594[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy603 := &x.ObjectMeta
					yy603.CodecEncodeSelf(e)
				}
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq594[3] {
					yy605 := &x.Spec
					yy605.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq594[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy606 := &x.Spec
					yy606.CodecEncodeSelf(e)
				}
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq594[4] {
					yy608 := &x.Status
					yy608.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq594[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy609 := &x.Status
					yy609.CodecEncodeSelf(e)
				}
			}
			if yyr594 || yy2arr594 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym610 := z.DecBinary()
	_ = yym610
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct611 := r.ContainerType()
		if yyct611 == codecSelferValueTypeMap1234 {
			yyl611 := r.ReadMapStart()
			if yyl611 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl611, d)
			}
		} else if yyct611 == codecSelferValueTypeArray1234 {
			yyl611 := r.ReadArrayStart()
			if yyl611 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl611, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys612Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys612Slc
	var yyhl612 bool = l >= 0
	for yyj612 := 0; ; yyj612++ {
		if yyhl612 {
			if yyj612 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys612Slc = r.DecodeBytes(yys612Slc, true, true)
		yys612 := string(yys612Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys612 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv615 := &x.ObjectMeta
				yyv615.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv616 := &x.Spec
				yyv616.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv617 := &x.Status
				yyv617.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys612)
		} // end switch yys612
	} // end for yyj612
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj618 int
	var yyb618 bool
	var yyhl618 bool = l >= 0
	yyj618++
	if yyhl618 {
		yyb618 = yyj618 > l
	} else {
		yyb618 = r.CheckBreak()
	}
	if yyb618 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj618++
	if yyhl618 {
		yyb618 = yyj618 > l
	} else {
		yyb618 = r.CheckBreak()
	}
	if yyb618 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj618++
	if yyhl618 {
		yyb618 = yyj618 > l
	} else {
		yyb618 = r.CheckBreak()
	}
	if yyb618 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv621 := &x.ObjectMeta
		yyv621.CodecDecodeSelf(d)
	}
	yyj618++
	if yyhl618 {
		yyb618 = yyj618 > l
	} else {
		yyb618 = r.CheckBreak()
	}
	if yyb618 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv622 := &x.Spec
		yyv622.CodecDecodeSelf(d)
	}
	yyj618++
	if yyhl618 {
		yyb618 = yyj618 > l
	} else {
		yyb618 = r.CheckBreak()
	}
	if yyb618 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv623 := &x.Status
		yyv623.CodecDecodeSelf(d)
	}
	for {
		yyj618++
		if yyhl618 {
			yyb618 = yyj618 > l
		} else {
			yyb618 = r.CheckBreak()
		}
		if yyb618 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj618-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym624 := z.EncBinary()
		_ = yym624
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep625 := !z.EncBinary()
			yy2arr625 := z.EncBasicHandle().StructToArray
			var yyq625 [4]bool
			_, _, _ = yysep625, yyq625, yy2arr625
			const yyr625 bool = false
			yyq625[0] = x.Kind != ""
			yyq625[1] = x.APIVersion != ""
			yyq625[2] = true
			var yynn625 int
			if yyr625 || yy2arr625 {
				r.EncodeArrayStart(4)
			} else {
				yynn625 = 1
				for _, b := range yyq625 {
					if b {
						yynn625++
					}
				}
				r.EncodeMapStart(yynn625)
				yynn625 = 0
			}
			if yyr625 || yy2arr625 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq625[0] {
					yym627 := z.EncBinary()
					_ = yym627
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq625[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym628 := z.EncBinary()
					_ = yym628
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr625 || yy2arr625 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq625[1] {
					yym630 := z.EncBinary()
					_ = yym630
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq625[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym631 := z.EncBinary()
					_ = yym631
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr625 || yy2arr625 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq625[2] {
					yy633 := &x.ListMeta
					yym634 := z.EncBinary()
					_ = yym634
					if false {
					} else if z.HasExtensions() && z.EncExt(yy633) {
					} else {
						z.EncFallback(yy633)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq625[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy635 := &x.ListMeta
					yym636 := z.EncBinary()
					_ = yym636
					if false {
					} else if z.HasExtensions() && z.EncExt(yy635) {
					} else {
						z.EncFallback(yy635)
					}
				}
			}
			if yyr625 || yy2arr625 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym638 := z.EncBinary()
					_ = yym638
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym639 := z.EncBinary()
					_ = yym639
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr625 || yy2arr625 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym640 := z.DecBinary()
	_ = yym640
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct641 := r.ContainerType()
		if yyct641 == codecSelferValueTypeMap1234 {
			yyl641 := r.ReadMapStart()
			if yyl641 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl641, d)
			}
		} else if yyct641 == codecSelferValueTypeArray1234 {
			yyl641 := r.ReadArrayStart()
			if yyl641 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl641, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DaemonSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys642Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys642Slc
	var yyhl642 bool = l >= 0
	for yyj642 := 0; ; yyj642++ {
		if yyhl642 {
			if yyj642 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys642Slc = r.DecodeBytes(yys642Slc, true, true)
		yys642 := string(yys642Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys642 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv645 := &x.ListMeta
				yym646 := z.DecBinary()
				_ = yym646
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv645) {
				} else {
					z.DecFallback(yyv645, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv647 := &x.Items
				yym648 := z.DecBinary()
				_ = yym648
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv647), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys642)
		} // end switch yys642
	} // end for yyj642
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj649 int
	var yyb649 bool
	var yyhl649 bool = l >= 0
	yyj649++
	if yyhl649 {
		yyb649 = yyj649 > l
	} else {
		yyb649 = r.CheckBreak()
	}
	if yyb649 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj649++
	if yyhl649 {
		yyb649 = yyj649 > l
	} else {
		yyb649 = r.CheckBreak()
	}
	if yyb649 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj649++
	if yyhl649 {
		yyb649 = yyj649 > l
	} else {
		yyb649 = r.CheckBreak()
	}
	if yyb649 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv652 := &x.ListMeta
		yym653 := z.DecBinary()
		_ = yym653
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv652) {
		} else {
			z.DecFallback(yyv652, false)
		}
	}
	yyj649++
	if yyhl649 {
		yyb649 = yyj649 > l
	} else {
		yyb649 = r.CheckBreak()
	}
	if yyb649 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv654 := &x.Items
		yym655 := z.DecBinary()
		_ = yym655
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv654), d)
		}
	}
	for {
		yyj649++
		if yyhl649 {
			yyb649 = yyj649 > l
		} else {
			yyb649 = r.CheckBreak()
		}
		if yyb649 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj649-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym656 := z.EncBinary()
		_ = yym656
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep657 := !z.EncBinary()
			yy2arr657 := z.EncBasicHandle().StructToArray
			var yyq657 [4]bool
			_, _, _ = yysep657, yyq657, yy2arr657
			const yyr657 bool = false
			yyq657[0] = x.Kind != ""
			yyq657[1] = x.APIVersion != ""
			yyq657[2] = true
			var yynn657 int
			if yyr657 || yy2arr657 {
				r.EncodeArrayStart(4)
			} else {
				yynn657 = 1
				for _, b := range yyq657 {
					if b {
						yynn657++
					}
				}
				r.EncodeMapStart(yynn657)
				yynn657 = 0
			}
			if yyr657 || yy2arr657 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq657[0] {
					yym659 := z.EncBinary()
					_ = yym659
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq657[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym660 := z.EncBinary()
					_ = yym660
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr657 || yy2arr657 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq657[1] {
					yym662 := z.EncBinary()
					_ = yym662
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq657[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym663 := z.EncBinary()
					_ = yym663
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr657 || yy2arr657 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq657[2] {
					yy665 := &x.ListMeta
					yym666 := z.EncBinary()
					_ = yym666
					if false {
					} else if z.HasExtensions() && z.EncExt(yy665) {
					} else {
						z.EncFallback(yy665)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq657[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy667 := &x.ListMeta
					yym668 := z.EncBinary()
					_ = yym668
					if false {
					} else if z.HasExtensions() && z.EncExt(yy667) {
					} else {
						z.EncFallback(yy667)
					}
				}
			}
			if yyr657 || yy2arr657 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym670 := z.EncBinary()
					_ = yym670
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym671 := z.EncBinary()
					_ = yym671
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr657 || yy2arr657 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym672 := z.DecBinary()
	_ = yym672
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct673 := r.ContainerType()
		if yyct673 == codecSelferValueTypeMap1234 {
			yyl673 := r.ReadMapStart()
			if yyl673 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl673, d)
			}
		} else if yyct673 == codecSelferValueTypeArray1234 {
			yyl673 := r.ReadArrayStart()
			if yyl673 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl673, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys674Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys674Slc
	var yyhl674 bool = l >= 0
	for yyj674 := 0; ; yyj674++ {
		if yyhl674 {
			if yyj674 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys674Slc = r.DecodeBytes(yys674Slc, true, true)
		yys674 := string(yys674Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys674 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv677 := &x.ListMeta
				yym678 := z.DecBinary()
				_ = yym678
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv677) {
				} else {
					z.DecFallback(yyv677, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv679 := &x.Items
				yym680 := z.DecBinary()
				_ = yym680
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv679), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys674)
		} // end switch yys674
	} // end for yyj674
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj681 int
	var yyb681 bool
	var yyhl681 bool = l >= 0
	yyj681++
	if yyhl681 {
		yyb681 = yyj681 > l
	} else {
		yyb681 = r.CheckBreak()
	}
	if yyb681 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj681++
	if yyhl681 {
		yyb681 = yyj681 > l
	} else {
		yyb681 = r.CheckBreak()
	}
	if yyb681 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj681++
	if yyhl681 {
		yyb681 = yyj681 > l
	} else {
		yyb681 = r.CheckBreak()
	}
	if yyb681 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv684 := &x.ListMeta
		yym685 := z.DecBinary()
		_ = yym685
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv684) {
		} else {
			z.DecFallback(yyv684, false)
		}
	}
	yyj681++
	if yyhl681 {
		yyb681 = yyj681 > l
	} else {
		yyb681 = r.CheckBreak()
	}
	if yyb681 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv686 := &x.Items
		yym687 := z.DecBinary()
		_ = yym687
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv686), d)
		}
	}
	for {
		yyj681++
		if yyhl681 {
			yyb681 = yyj681 > l
		} else {
			yyb681 = r.CheckBreak()
		}
		if yyb681 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj681-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym688 := z.EncBinary()
		_ = yym688
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep689 := !z.EncBinary()
			yy2arr689 := z.EncBasicHandle().StructToArray
			var yyq689 [5]bool
			_, _, _ = yysep689, yyq689, yy2arr689
			const yyr689 bool = false
			yyq689[0] = x.Kind != ""
			yyq689[1] = x.APIVersion != ""
			yyq689[2] = true
			yyq689[3] = true
			yyq689[4] = true
			var yynn689 int
			if yyr689 || yy2arr689 {
				r.EncodeArrayStart(5)
			} else {
				yynn689 = 0
				for _, b := range yyq689 {
					if b {
						yynn689++
					}
				}
				r.EncodeMapStart(yynn689)
				yynn689 = 0
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq689[0] {
					yym691 := z.EncBinary()
					_ = yym691
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq689[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym692 := z.EncBinary()
					_ = yym692
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq689[1] {
					yym694 := z.EncBinary()
					_ = yym694
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq689[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym695 := z.EncBinary()
					_ = yym695
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq689[2] {
					yy697 := &x.ObjectMeta
					yy697.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq689[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy698 := &x.ObjectMeta
					yy698.CodecEncodeSelf(e)
				}
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq689[3] {
					yy700 := &x.Spec
					yy700.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq689[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy701 := &x.Spec
					yy701.CodecEncodeSelf(e)
				}
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq689[4] {
					yy703 := &x.Status
					yy703.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq689[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy704 := &x.Status
					yy704.CodecEncodeSelf(e)
				}
			}
			if yyr689 || yy2arr689 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym705 := z.DecBinary()
	_ = yym705
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct706 := r.ContainerType()
		if yyct706 == codecSelferValueTypeMap1234 {
			yyl706 := r.ReadMapStart()
			if yyl706 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl706, d)
			}
		} else if yyct706 == codecSelferValueTypeArray1234 {
			yyl706 := r.ReadArrayStart()
			if yyl706 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl706, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys707Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys707Slc
	var yyhl707 bool = l >= 0
	for yyj707 := 0; ; yyj707++ {
		if yyhl707 {
			if yyj707 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys707Slc = r.DecodeBytes(yys707Slc, true, true)
		yys707 := string(yys707Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys707 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv710 := &x.ObjectMeta
				yyv710.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv711 := &x.Spec
				yyv711.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv712 := &x.Status
				yyv712.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys707)
		} // end switch yys707
	} // end for yyj707
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj713 int
	var yyb713 bool
	var yyhl713 bool = l >= 0
	yyj713++
	if yyhl713 {
		yyb713 = yyj713 > l
	} else {
		yyb713 = r.CheckBreak()
	}
	if yyb713 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj713++
	if yyhl713 {
		yyb713 = yyj713 > l
	} else {
		yyb713 = r.CheckBreak()
	}
	if yyb713 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj713++
	if yyhl713 {
		yyb713 = yyj713 > l
	} else {
		yyb713 = r.CheckBreak()
	}
	if yyb713 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv716 := &x.ObjectMeta
		yyv716.CodecDecodeSelf(d)
	}
	yyj713++
	if yyhl713 {
		yyb713 = yyj713 > l
	} else {
		yyb713 = r.CheckBreak()
	}
	if yyb713 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv717 := &x.Spec
		yyv717.CodecDecodeSelf(d)
	}
	yyj713++
	if yyhl713 {
		yyb713 = yyj713 > l
	} else {
		yyb713 = r.CheckBreak()
	}
	if yyb713 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv718 := &x.Status
		yyv718.CodecDecodeSelf(d)
	}
	for {
		yyj713++
		if yyhl713 {
			yyb713 = yyj713 > l
		} else {
			yyb713 = r.CheckBreak()
		}
		if yyb713 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj713-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym719 := z.EncBinary()
		_ = yym719
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep720 := !z.EncBinary()
			yy2arr720 := z.EncBasicHandle().StructToArray
			var yyq720 [4]bool
			_, _, _ = yysep720, yyq720, yy2arr720
			const yyr720 bool = false
			yyq720[0] = x.Kind != ""
			yyq720[1] = x.APIVersion != ""
			yyq720[2] = true
			var yynn720 int
			if yyr720 || yy2arr720 {
				r.EncodeArrayStart(4)
			} else {
				yynn720 = 1
				for _, b := range yyq720 {
					if b {
						yynn720++
					}
				}
				r.EncodeMapStart(yynn720)
				yynn720 = 0
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[0] {
					yym722 := z.EncBinary()
					_ = yym722
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq720[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym723 := z.EncBinary()
					_ = yym723
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[1] {
					yym725 := z.EncBinary()
					_ = yym725
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq720[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym726 := z.EncBinary()
					_ = yym726
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[2] {
					yy728 := &x.ListMeta
					yym729 := z.EncBinary()
					_ = yym729
					if false {
					} else if z.HasExtensions() && z.EncExt(yy728) {
					} else {
						z.EncFallback(yy728)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq720[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy730 := &x.ListMeta
					yym731 := z.EncBinary()
					_ = yym731
					if false {
					} else if z.HasExtensions() && z.EncExt(yy730) {
					} else {
						z.EncFallback(yy730)
					}
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym733 := z.EncBinary()
					_ = yym733
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym734 := z.EncBinary()
					_ = yym734
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym735 := z.DecBinary()
	_ = yym735
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct736 := r.ContainerType()
		if yyct736 == codecSelferValueTypeMap1234 {
			yyl736 := r.ReadMapStart()
			if yyl736 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl736, d)
			}
		} else if yyct736 == codecSelferValueTypeArray1234 {
			yyl736 := r.ReadArrayStart()
			if yyl736 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl736, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *JobList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys737Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys737Slc
	var yyhl737 bool = l >= 0
	for yyj737 := 0; ; yyj737++ {
		if yyhl737 {
			if yyj737 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys737Slc = r.DecodeBytes(yys737Slc, true, true)
		yys737 := string(yys737Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys737 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv740 := &x.ListMeta
				yym741 := z.DecBinary()
				_ = yym741
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv740) {
				} else {
					z.DecFallback(yyv740, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv742 := &x.Items
				yym743 := z.DecBinary()
				_ = yym743
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv742), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys737)
		} // end switch yys737
	} // end for yyj737
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj744 int
	var yyb744 bool
	var yyhl744 bool = l >= 0
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv747 := &x.ListMeta
		yym748 := z.DecBinary()
		_ = yym748
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv747) {
		} else {
			z.DecFallback(yyv747, false)
		}
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv749 := &x.Items
		yym750 := z.DecBinary()
		_ = yym750
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv749), d)
		}
	}
	for {
		yyj744++
		if yyhl744 {
			yyb744 = yyj744 > l
		} else {
			yyb744 = r.CheckBreak()
		}
		if yyb744 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj744-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym751 := z.EncBinary()
		_ = yym751
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep752 := !z.EncBinary()
			yy2arr752 := z.EncBasicHandle().StructToArray
			var yyq752 [5]bool
			_, _, _ = yysep752, yyq752, yy2arr752
			const yyr752 bool = false
			yyq752[0] = x.Parallelism != nil
			yyq752[1] = x.Completions != nil
			yyq752[2] = x.ActiveDeadlineSeconds != nil
			yyq752[3] = x.Selector != nil
			var yynn752 int
			if yyr752 || yy2arr752 {
				r.EncodeArrayStart(5)
			} else {
				yynn752 = 1
				for _, b := range yyq752 {
					if b {
						yynn752++
					}
				}
				r.EncodeMapStart(yynn752)
				yynn752 = 0
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq752[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy754 := *x.Parallelism
						yym755 := z.EncBinary()
						_ = yym755
						if false {
						} else {
							r.EncodeInt(int64(yy754))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq752[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy756 := *x.Parallelism
						yym757 := z.EncBinary()
						_ = yym757
						if false {
						} else {
							r.EncodeInt(int64(yy756))
						}
					}
				}
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq752[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy759 := *x.Completions
						yym760 := z.EncBinary()
						_ = yym760
						if false {
						} else {
							r.EncodeInt(int64(yy759))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq752[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy761 := *x.Completions
						yym762 := z.EncBinary()
						_ = yym762
						if false {
						} else {
							r.EncodeInt(int64(yy761))
						}
					}
				}
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq752[2] {
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy764 := *x.ActiveDeadlineSeconds
						yym765 := z.EncBinary()
						_ = yym765
						if false {
						} else {
							r.EncodeInt(int64(yy764))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq752[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy766 := *x.ActiveDeadlineSeconds
						yym767 := z.EncBinary()
						_ = yym767
						if false {
						} else {
							r.EncodeInt(int64(yy766))
						}
					}
				}
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq752[3] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq752[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy770 := &x.Template
				yy770.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy771 := &x.Template
				yy771.CodecEncodeSelf(e)
			}
			if yyr752 || yy2arr752 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym772 := z.DecBinary()
	_ = yym772
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct773 := r.ContainerType()
		if yyct773 == codecSelferValueTypeMap1234 {
			yyl773 := r.ReadMapStart()
			if yyl773 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl773, d)
			}
		} else if yyct773 == codecSelferValueTypeArray1234 {
			yyl773 := r.ReadArrayStart()
			if yyl773 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl773, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *JobSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys774Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys774Slc
	var yyhl774 bool = l >= 0
	for yyj774 := 0; ; yyj774++ {
		if yyhl774 {
			if yyj774 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys774Slc = r.DecodeBytes(yys774Slc, true, true)
		yys774 := string(yys774Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys774 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int32)
				}
				yym776 := z.DecBinary()
				_ = yym776
				if false {
				} else {
					*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
				}
			}
		case "completions":
			if r.TryDecodeAsNil() {
				if x.Completions != nil {
					x.Completions = nil
				}
			} else {
				if x.Completions == nil {
					x.Completions = new(int32)
				}
				yym778 := z.DecBinary()
				_ = yym778
				if false {
				} else {
					*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
				}
			}
		case "activeDeadlineSeconds":
			if r.TryDecodeAsNil() {
				if x.ActiveDeadlineSeconds != nil {
					x.ActiveDeadlineSeconds = nil
				}
			} else {
				if x.ActiveDeadlineSeconds == nil {
					x.ActiveDeadlineSeconds = new(int64)
				}
				yym780 := z.DecBinary()
				_ = yym780
				if false {
				} else {
					*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv782 := &x.Template
				yyv782.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys774)
		} // end switch yys774
	} // end for yyj774
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj783 int
	var yyb783 bool
	var yyhl783 bool = l >= 0
	yyj783++
	if yyhl783 {
		yyb783 = yyj783 > l
	} else {
		yyb783 = r.CheckBreak()
	}
	if yyb783 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int32)
		}
		yym785 := z.DecBinary()
		_ = yym785
		if false {
		} else {
			*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
		}
	}
	yyj783++
	if yyhl783 {
		yyb783 = yyj783 > l
	} else {
		yyb783 = r.CheckBreak()
	}
	if yyb783 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int32)
		}
		yym787 := z.DecBinary()
		_ = yym787
		if false {
		} else {
			*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
		}
	}
	yyj783++
	if yyhl783 {
		yyb783 = yyj783 > l
	} else {
		yyb783 = r.CheckBreak()
	}
	if yyb783 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ActiveDeadlineSeconds != nil {
			x.ActiveDeadlineSeconds = nil
		}
	} else {
		if x.ActiveDeadlineSeconds == nil {
			x.ActiveDeadlineSeconds = new(int64)
		}
		yym789 := z.DecBinary()
		_ = yym789
		if false {
		} else {
			*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj783++
	if yyhl783 {
		yyb783 = yyj783 > l
	} else {
		yyb783 = r.CheckBreak()
	}
	if yyb783 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj783++
	if yyhl783 {
		yyb783 = yyj783 > l
	} else {
		yyb783 = r.CheckBreak()
	}
	if yyb783 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv791 := &x.Template
		yyv791.CodecDecodeSelf(d)
	}
	for {
		yyj783++
		if yyhl783 {
			yyb783 = yyj783 > l
		} else {
			yyb783 = r.CheckBreak()
		}
		if yyb783 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj783-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym792 := z.EncBinary()
		_ = yym792
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep793 := !z.EncBinary()
			yy2arr793 := z.EncBasicHandle().StructToArray
			var yyq793 [6]bool
			_, _, _ = yysep793, yyq793, yy2arr793
			const yyr793 bool = false
			yyq793[0] = len(x.Conditions) != 0
			yyq793[1] = x.StartTime != nil
			yyq793[2] = x.CompletionTime != nil
			yyq793[3] = x.Active != 0
			yyq793[4] = x.Succeeded != 0
			yyq793[5] = x.Failed != 0
			var yynn793 int
			if yyr793 || yy2arr793 {
				r.EncodeArrayStart(6)
			} else {
				yynn793 = 0
				for _, b := range yyq793 {
					if b {
						yynn793++
					}
				}
				r.EncodeMapStart(yynn793)
				yynn793 = 0
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym795 := z.EncBinary()
						_ = yym795
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq793[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym796 := z.EncBinary()
						_ = yym796
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym798 := z.EncBinary()
						_ = yym798
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym798 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym798 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq793[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym799 := z.EncBinary()
						_ = yym799
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym799 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym799 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym801 := z.EncBinary()
						_ = yym801
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym801 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym801 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq793[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym802 := z.EncBinary()
						_ = yym802
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym802 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym802 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[3] {
					yym804 := z.EncBinary()
					_ = yym804
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq793[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[4] {
					yym807 := z.EncBinary()
					_ = yym807
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq793[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym808 := z.EncBinary()
					_ = yym808
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq793[5] {
					yym810 := z.EncBinary()
					_ = yym810
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq793[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym811 := z.EncBinary()
					_ = yym811
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yyr793 || yy2arr793 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym812 := z.DecBinary()
	_ = yym812
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct813 := r.ContainerType()
		if yyct813 == codecSelferValueTypeMap1234 {
			yyl813 := r.ReadMapStart()
			if yyl813 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl813, d)
			}
		} else if yyct813 == codecSelferValueTypeArray1234 {
			yyl813 := r.ReadArrayStart()
			if yyl813 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl813, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *JobStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys814Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys814Slc
	var yyhl814 bool = l >= 0
	for yyj814 := 0; ; yyj814++ {
		if yyhl814 {
			if yyj814 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys814Slc = r.DecodeBytes(yys814Slc, true, true)
		yys814 := string(yys814Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys814 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv815 := &x.Conditions
				yym816 := z.DecBinary()
				_ = yym816
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv815), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym818 := z.DecBinary()
				_ = yym818
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym818 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym818 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.StartTime)
				} else {
					z.DecFallback(x.StartTime, false)
				}
			}
		case "completionTime":
			if r.TryDecodeAsNil() {
				if x.CompletionTime != nil {
					x.CompletionTime = nil
				}
			} else {
				if x.CompletionTime == nil {
					x.CompletionTime = new(pkg1_unversioned.Time)
				}
				yym820 := z.DecBinary()
				_ = yym820
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym820 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym820 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.CompletionTime)
				} else {
					z.DecFallback(x.CompletionTime, false)
				}
			}
		case "active":
			if r.TryDecodeAsNil() {
				x.Active = 0
			} else {
				x.Active = int32(r.DecodeInt(32))
			}
		case "succeeded":
			if r.TryDecodeAsNil() {
				x.Succeeded = 0
			} else {
				x.Succeeded = int32(r.DecodeInt(32))
			}
		case "failed":
			if r.TryDecodeAsNil() {
				x.Failed = 0
			} else {
				x.Failed = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys814)
		} // end switch yys814
	} // end for yyj814
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj824 int
	var yyb824 bool
	var yyhl824 bool = l >= 0
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv825 := &x.Conditions
		yym826 := z.DecBinary()
		_ = yym826
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv825), d)
		}
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.StartTime != nil {
			x.StartTime = nil
		}
	} else {
		if x.StartTime == nil {
			x.StartTime = new(pkg1_unversioned.Time)
		}
		yym828 := z.DecBinary()
		_ = yym828
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym828 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym828 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CompletionTime != nil {
			x.CompletionTime = nil
		}
	} else {
		if x.CompletionTime == nil {
			x.CompletionTime = new(pkg1_unversioned.Time)
		}
		yym830 := z.DecBinary()
		_ = yym830
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym830 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym830 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int32(r.DecodeInt(32))
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int32(r.DecodeInt(32))
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int32(r.DecodeInt(32))
	}
	for {
		yyj824++
		if yyhl824 {
			yyb824 = yyj824 > l
		} else {
			yyb824 = r.CheckBreak()
		}
		if yyb824 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj824-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym834 := z.EncBinary()
	_ = yym834
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *JobConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym835 := z.DecBinary()
	_ = yym835
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *JobCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym836 := z.EncBinary()
		_ = yym836
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep837 := !z.EncBinary()
			yy2arr837 := z.EncBasicHandle().StructToArray
			var yyq837 [6]bool
			_, _, _ = yysep837, yyq837, yy2arr837
			const yyr837 bool = false
			yyq837[2] = true
			yyq837[3] = true
			yyq837[4] = x.Reason != ""
			yyq837[5] = x.Message != ""
			var yynn837 int
			if yyr837 || yy2arr837 {
				r.EncodeArrayStart(6)
			} else {
				yynn837 = 2
				for _, b := range yyq837 {
					if b {
						yynn837++
					}
				}
				r.EncodeMapStart(yynn837)
				yynn837 = 0
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym840 := z.EncBinary()
				_ = yym840
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym841 := z.EncBinary()
				_ = yym841
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[2] {
					yy843 := &x.LastProbeTime
					yym844 := z.EncBinary()
					_ = yym844
					if false {
					} else if z.HasExtensions() && z.EncExt(yy843) {
					} else if yym844 {
						z.EncBinaryMarshal(yy843)
					} else if !yym844 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy843)
					} else {
						z.EncFallback(yy843)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy845 := &x.LastProbeTime
					yym846 := z.EncBinary()
					_ = yym846
					if false {
					} else if z.HasExtensions() && z.EncExt(yy845) {
					} else if yym846 {
						z.EncBinaryMarshal(yy845)
					} else if !yym846 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy845)
					} else {
						z.EncFallback(yy845)
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[3] {
					yy848 := &x.LastTransitionTime
					yym849 := z.EncBinary()
					_ = yym849
					if false {
					} else if z.HasExtensions() && z.EncExt(yy848) {
					} else if yym849 {
						z.EncBinaryMarshal(yy848)
					} else if !yym849 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy848)
					} else {
						z.EncFallback(yy848)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy850 := &x.LastTransitionTime
					yym851 := z.EncBinary()
					_ = yym851
					if false {
					} else if z.HasExtensions() && z.EncExt(yy850) {
					} else if yym851 {
						z.EncBinaryMarshal(yy850)
					} else if !yym851 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy850)
					} else {
						z.EncFallback(yy850)
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[4] {
					yym853 := z.EncBinary()
					_ = yym853
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq837[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym854 := z.EncBinary()
					_ = yym854
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[5] {
					yym856 := z.EncBinary()
					_ = yym856
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq837[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym857 := z.EncBinary()
					_ = yym857
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym858 := z.DecBinary()
	_ = yym858
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct859 := r.ContainerType()
		if yyct859 == codecSelferValueTypeMap1234 {
			yyl859 := r.ReadMapStart()
			if yyl859 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl859, d)
			}
		} else if yyct859 == codecSelferValueTypeArray1234 {
			yyl859 := r.ReadArrayStart()
			if yyl859 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl859, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *JobCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys860Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys860Slc
	var yyhl860 bool = l >= 0
	for yyj860 := 0; ; yyj860++ {
		if yyhl860 {
			if yyj860 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys860Slc = r.DecodeBytes(yys860Slc, true, true)
		yys860 := string(yys860Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys860 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = JobConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
			}
		case "lastProbeTime":
			if r.TryDecodeAsNil() {
				x.LastProbeTime = pkg1_unversioned.Time{}
			} else {
				yyv863 := &x.LastProbeTime
				yym864 := z.DecBinary()
				_ = yym864
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv863) {
				} else if yym864 {
					z.DecBinaryUnmarshal(yyv863)
				} else if !yym864 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv863)
				} else {
					z.DecFallback(yyv863, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv865 := &x.LastTransitionTime
				yym866 := z.DecBinary()
				_ = yym866
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv865) {
				} else if yym866 {
					z.DecBinaryUnmarshal(yyv865)
				} else if !yym866 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv865)
				} else {
					z.DecFallback(yyv865, false)
				}
			}
		case "reason":
			if r.TryDecodeAsNil() {
				x.Reason = ""
			} else {
				x.Reason = string(r.DecodeString())
			}
		case "message":
			if r.TryDecodeAsNil() {
				x.Message = ""
			} else {
				x.Message = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys860)
		} // end switch yys860
	} // end for yyj860
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj869 int
	var yyb869 bool
	var yyhl869 bool = l >= 0
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv872 := &x.LastProbeTime
		yym873 := z.DecBinary()
		_ = yym873
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv872) {
		} else if yym873 {
			z.DecBinaryUnmarshal(yyv872)
		} else if !yym873 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv872)
		} else {
			z.DecFallback(yyv872, false)
		}
	}
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv874 := &x.LastTransitionTime
		yym875 := z.DecBinary()
		_ = yym875
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv874) {
		} else if yym875 {
			z.DecBinaryUnmarshal(yyv874)
		} else if !yym875 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv874)
		} else {
			z.DecFallback(yyv874, false)
		}
	}
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj869++
	if yyhl869 {
		yyb869 = yyj869 > l
	} else {
		yyb869 = r.CheckBreak()
	}
	if yyb869 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj869++
		if yyhl869 {
			yyb869 = yyj869 > l
		} else {
			yyb869 = r.CheckBreak()
		}
		if yyb869 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj869-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym878 := z.EncBinary()
		_ = yym878
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep879 := !z.EncBinary()
			yy2arr879 := z.EncBasicHandle().StructToArray
			var yyq879 [5]bool
			_, _, _ = yysep879, yyq879, yy2arr879
			const yyr879 bool = false
			yyq879[0] = x.Kind != ""
			yyq879[1] = x.APIVersion != ""
			yyq879[2] = true
			yyq879[3] = true
			yyq879[4] = true
			var yynn879 int
			if yyr879 || yy2arr879 {
				r.EncodeArrayStart(5)
			} else {
				yynn879 = 0
				for _, b := range yyq879 {
					if b {
						yynn879++
					}
				}
				r.EncodeMapStart(yynn879)
				yynn879 = 0
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq879[0] {
					yym881 := z.EncBinary()
					_ = yym881
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq879[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym882 := z.EncBinary()
					_ = yym882
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq879[1] {
					yym884 := z.EncBinary()
					_ = yym884
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq879[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym885 := z.EncBinary()
					_ = yym885
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq879[2] {
					yy887 := &x.ObjectMeta
					yy887.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq879[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy888 := &x.ObjectMeta
					yy888.CodecEncodeSelf(e)
				}
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq879[3] {
					yy890 := &x.Spec
					yy890.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq879[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy891 := &x.Spec
					yy891.CodecEncodeSelf(e)
				}
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq879[4] {
					yy893 := &x.Status
					yy893.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq879[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy894 := &x.Status
					yy894.CodecEncodeSelf(e)
				}
			}
			if yyr879 || yy2arr879 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym895 := z.DecBinary()
	_ = yym895
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct896 := r.ContainerType()
		if yyct896 == codecSelferValueTypeMap1234 {
			yyl896 := r.ReadMapStart()
			if yyl896 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl896, d)
			}
		} else if yyct896 == codecSelferValueTypeArray1234 {
			yyl896 := r.ReadArrayStart()
			if yyl896 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl896, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Ingress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys897Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys897Slc
	var yyhl897 bool = l >= 0
	for yyj897 := 0; ; yyj897++ {
		if yyhl897 {
			if yyj897 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys897Slc = r.DecodeBytes(yys897Slc, true, true)
		yys897 := string(yys897Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys897 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv900 := &x.ObjectMeta
				yyv900.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv901 := &x.Spec
				yyv901.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv902 := &x.Status
				yyv902.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys897)
		} // end switch yys897
	} // end for yyj897
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj903 int
	var yyb903 bool
	var yyhl903 bool = l >= 0
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv906 := &x.ObjectMeta
		yyv906.CodecDecodeSelf(d)
	}
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv907 := &x.Spec
		yyv907.CodecDecodeSelf(d)
	}
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv908 := &x.Status
		yyv908.CodecDecodeSelf(d)
	}
	for {
		yyj903++
		if yyhl903 {
			yyb903 = yyj903 > l
		} else {
			yyb903 = r.CheckBreak()
		}
		if yyb903 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj903-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym909 := z.EncBinary()
		_ = yym909
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep910 := !z.EncBinary()
			yy2arr910 := z.EncBasicHandle().StructToArray
			var yyq910 [4]bool
			_, _, _ = yysep910, yyq910, yy2arr910
			const yyr910 bool = false
			yyq910[0] = x.Kind != ""
			yyq910[1] = x.APIVersion != ""
			yyq910[2] = true
			var yynn910 int
			if yyr910 || yy2arr910 {
				r.EncodeArrayStart(4)
			} else {
				yynn910 = 1
				for _, b := range yyq910 {
					if b {
						yynn910++
					}
				}
				r.EncodeMapStart(yynn910)
				yynn910 = 0
			}
			if yyr910 || yy2arr910 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq910[0] {
					yym912 := z.EncBinary()
					_ = yym912
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq910[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym913 := z.EncBinary()
					_ = yym913
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr910 || yy2arr910 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq910[1] {
					yym915 := z.EncBinary()
					_ = yym915
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq910[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym916 := z.EncBinary()
					_ = yym916
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr910 || yy2arr910 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq910[2] {
					yy918 := &x.ListMeta
					yym919 := z.EncBinary()
					_ = yym919
					if false {
					} else if z.HasExtensions() && z.EncExt(yy918) {
					} else {
						z.EncFallback(yy918)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq910[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy920 := &x.ListMeta
					yym921 := z.EncBinary()
					_ = yym921
					if false {
					} else if z.HasExtensions() && z.EncExt(yy920) {
					} else {
						z.EncFallback(yy920)
					}
				}
			}
			if yyr910 || yy2arr910 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym923 := z.EncBinary()
					_ = yym923
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym924 := z.EncBinary()
					_ = yym924
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr910 || yy2arr910 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym925 := z.DecBinary()
	_ = yym925
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct926 := r.ContainerType()
		if yyct926 == codecSelferValueTypeMap1234 {
			yyl926 := r.ReadMapStart()
			if yyl926 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl926, d)
			}
		} else if yyct926 == codecSelferValueTypeArray1234 {
			yyl926 := r.ReadArrayStart()
			if yyl926 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl926, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys927Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys927Slc
	var yyhl927 bool = l >= 0
	for yyj927 := 0; ; yyj927++ {
		if yyhl927 {
			if yyj927 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys927Slc = r.DecodeBytes(yys927Slc, true, true)
		yys927 := string(yys927Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys927 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv930 := &x.ListMeta
				yym931 := z.DecBinary()
				_ = yym931
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv930) {
				} else {
					z.DecFallback(yyv930, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv932 := &x.Items
				yym933 := z.DecBinary()
				_ = yym933
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv932), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys927)
		} // end switch yys927
	} // end for yyj927
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj934 int
	var yyb934 bool
	var yyhl934 bool = l >= 0
	yyj934++
	if yyhl934 {
		yyb934 = yyj934 > l
	} else {
		yyb934 = r.CheckBreak()
	}
	if yyb934 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj934++
	if yyhl934 {
		yyb934 = yyj934 > l
	} else {
		yyb934 = r.CheckBreak()
	}
	if yyb934 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj934++
	if yyhl934 {
		yyb934 = yyj934 > l
	} else {
		yyb934 = r.CheckBreak()
	}
	if yyb934 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv937 := &x.ListMeta
		yym938 := z.DecBinary()
		_ = yym938
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv937) {
		} else {
			z.DecFallback(yyv937, false)
		}
	}
	yyj934++
	if yyhl934 {
		yyb934 = yyj934 > l
	} else {
		yyb934 = r.CheckBreak()
	}
	if yyb934 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv939 := &x.Items
		yym940 := z.DecBinary()
		_ = yym940
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv939), d)
		}
	}
	for {
		yyj934++
		if yyhl934 {
			yyb934 = yyj934 > l
		} else {
			yyb934 = r.CheckBreak()
		}
		if yyb934 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj934-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym941 := z.EncBinary()
		_ = yym941
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep942 := !z.EncBinary()
			yy2arr942 := z.EncBasicHandle().StructToArray
			var yyq942 [2]bool
			_, _, _ = yysep942, yyq942, yy2arr942
			const yyr942 bool = false
			yyq942[0] = x.Backend != nil
			yyq942[1] = len(x.Rules) != 0
			var yynn942 int
			if yyr942 || yy2arr942 {
				r.EncodeArrayStart(2)
			} else {
				yynn942 = 0
				for _, b := range yyq942 {
					if b {
						yynn942++
					}
				}
				r.EncodeMapStart(yynn942)
				yynn942 = 0
			}
			if yyr942 || yy2arr942 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq942[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq942[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr942 || yy2arr942 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq942[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym945 := z.EncBinary()
						_ = yym945
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq942[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym946 := z.EncBinary()
						_ = yym946
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr942 || yy2arr942 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym947 := z.DecBinary()
	_ = yym947
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct948 := r.ContainerType()
		if yyct948 == codecSelferValueTypeMap1234 {
			yyl948 := r.ReadMapStart()
			if yyl948 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl948, d)
			}
		} else if yyct948 == codecSelferValueTypeArray1234 {
			yyl948 := r.ReadArrayStart()
			if yyl948 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl948, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys949Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys949Slc
	var yyhl949 bool = l >= 0
	for yyj949 := 0; ; yyj949++ {
		if yyhl949 {
			if yyj949 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys949Slc = r.DecodeBytes(yys949Slc, true, true)
		yys949 := string(yys949Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys949 {
		case "backend":
			if r.TryDecodeAsNil() {
				if x.Backend != nil {
					x.Backend = nil
				}
			} else {
				if x.Backend == nil {
					x.Backend = new(IngressBackend)
				}
				x.Backend.CodecDecodeSelf(d)
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv951 := &x.Rules
				yym952 := z.DecBinary()
				_ = yym952
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv951), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys949)
		} // end switch yys949
	} // end for yyj949
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj953 int
	var yyb953 bool
	var yyhl953 bool = l >= 0
	yyj953++
	if yyhl953 {
		yyb953 = yyj953 > l
	} else {
		yyb953 = r.CheckBreak()
	}
	if yyb953 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Backend != nil {
			x.Backend = nil
		}
	} else {
		if x.Backend == nil {
			x.Backend = new(IngressBackend)
		}
		x.Backend.CodecDecodeSelf(d)
	}
	yyj953++
	if yyhl953 {
		yyb953 = yyj953 > l
	} else {
		yyb953 = r.CheckBreak()
	}
	if yyb953 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv955 := &x.Rules
		yym956 := z.DecBinary()
		_ = yym956
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv955), d)
		}
	}
	for {
		yyj953++
		if yyhl953 {
			yyb953 = yyj953 > l
		} else {
			yyb953 = r.CheckBreak()
		}
		if yyb953 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj953-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym957 := z.EncBinary()
		_ = yym957
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep958 := !z.EncBinary()
			yy2arr958 := z.EncBasicHandle().StructToArray
			var yyq958 [1]bool
			_, _, _ = yysep958, yyq958, yy2arr958
			const yyr958 bool = false
			yyq958[0] = true
			var yynn958 int
			if yyr958 || yy2arr958 {
				r.EncodeArrayStart(1)
			} else {
				yynn958 = 0
				for _, b := range yyq958 {
					if b {
						yynn958++
					}
				}
				r.EncodeMapStart(yynn958)
				yynn958 = 0
			}
			if yyr958 || yy2arr958 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq958[0] {
					yy960 := &x.LoadBalancer
					yy960.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq958[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy961 := &x.LoadBalancer
					yy961.CodecEncodeSelf(e)
				}
			}
			if yyr958 || yy2arr958 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym962 := z.DecBinary()
	_ = yym962
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct963 := r.ContainerType()
		if yyct963 == codecSelferValueTypeMap1234 {
			yyl963 := r.ReadMapStart()
			if yyl963 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl963, d)
			}
		} else if yyct963 == codecSelferValueTypeArray1234 {
			yyl963 := r.ReadArrayStart()
			if yyl963 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl963, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys964Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys964Slc
	var yyhl964 bool = l >= 0
	for yyj964 := 0; ; yyj964++ {
		if yyhl964 {
			if yyj964 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys964Slc = r.DecodeBytes(yys964Slc, true, true)
		yys964 := string(yys964Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys964 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
			} else {
				yyv965 := &x.LoadBalancer
				yyv965.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys964)
		} // end switch yys964
	} // end for yyj964
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj966 int
	var yyb966 bool
	var yyhl966 bool = l >= 0
	yyj966++
	if yyhl966 {
		yyb966 = yyj966 > l
	} else {
		yyb966 = r.CheckBreak()
	}
	if yyb966 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv967 := &x.LoadBalancer
		yyv967.CodecDecodeSelf(d)
	}
	for {
		yyj966++
		if yyhl966 {
			yyb966 = yyj966 > l
		} else {
			yyb966 = r.CheckBreak()
		}
		if yyb966 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj966-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym968 := z.EncBinary()
		_ = yym968
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep969 := !z.EncBinary()
			yy2arr969 := z.EncBasicHandle().StructToArray
			var yyq969 [2]bool
			_, _, _ = yysep969, yyq969, yy2arr969
			const yyr969 bool = false
			yyq969[0] = x.Host != ""
			yyq969[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn969 int
			if yyr969 || yy2arr969 {
				r.EncodeArrayStart(2)
			} else {
				yynn969 = 0
				for _, b := range yyq969 {
					if b {
						yynn969++
					}
				}
				r.EncodeMapStart(yynn969)
				yynn969 = 0
			}
			if yyr969 || yy2arr969 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq969[0] {
					yym971 := z.EncBinary()
					_ = yym971
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq969[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym972 := z.EncBinary()
					_ = yym972
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn973 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn973 = true
				goto LABEL973
			}
		LABEL973:
			if yyr969 || yy2arr969 {
				if yyn973 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq969[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq969[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn973 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr969 || yy2arr969 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym974 := z.DecBinary()
	_ = yym974
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct975 := r.ContainerType()
		if yyct975 == codecSelferValueTypeMap1234 {
			yyl975 := r.ReadMapStart()
			if yyl975 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl975, d)
			}
		} else if yyct975 == codecSelferValueTypeArray1234 {
			yyl975 := r.ReadArrayStart()
			if yyl975 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl975, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys976Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys976Slc
	var yyhl976 bool = l >= 0
	for yyj976 := 0; ; yyj976++ {
		if yyhl976 {
			if yyj976 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys976Slc = r.DecodeBytes(yys976Slc, true, true)
		yys976 := string(yys976Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys976 {
		case "host":
			if r.TryDecodeAsNil() {
				x.Host = ""
			} else {
				x.Host = string(r.DecodeString())
			}
		case "http":
			if x.IngressRuleValue.HTTP == nil {
				x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
			}
			if r.TryDecodeAsNil() {
				if x.HTTP != nil {
					x.HTTP = nil
				}
			} else {
				if x.HTTP == nil {
					x.HTTP = new(HTTPIngressRuleValue)
				}
				x.HTTP.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys976)
		} // end switch yys976
	} // end for yyj976
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj979 int
	var yyb979 bool
	var yyhl979 bool = l >= 0
	yyj979++
	if yyhl979 {
		yyb979 = yyj979 > l
	} else {
		yyb979 = r.CheckBreak()
	}
	if yyb979 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Host = ""
	} else {
		x.Host = string(r.DecodeString())
	}
	if x.IngressRuleValue.HTTP == nil {
		x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
	}
	yyj979++
	if yyhl979 {
		yyb979 = yyj979 > l
	} else {
		yyb979 = r.CheckBreak()
	}
	if yyb979 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj979++
		if yyhl979 {
			yyb979 = yyj979 > l
		} else {
			yyb979 = r.CheckBreak()
		}
		if yyb979 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj979-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym982 := z.EncBinary()
		_ = yym982
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep983 := !z.EncBinary()
			yy2arr983 := z.EncBasicHandle().StructToArray
			var yyq983 [1]bool
			_, _, _ = yysep983, yyq983, yy2arr983
			const yyr983 bool = false
			yyq983[0] = x.HTTP != nil
			var yynn983 int
			if yyr983 || yy2arr983 {
				r.EncodeArrayStart(1)
			} else {
				yynn983 = 0
				for _, b := range yyq983 {
					if b {
						yynn983++
					}
				}
				r.EncodeMapStart(yynn983)
				yynn983 = 0
			}
			if yyr983 || yy2arr983 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq983[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq983[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				}
			}
			if yyr983 || yy2arr983 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym985 := z.DecBinary()
	_ = yym985
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct986 := r.ContainerType()
		if yyct986 == codecSelferValueTypeMap1234 {
			yyl986 := r.ReadMapStart()
			if yyl986 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl986, d)
			}
		} else if yyct986 == codecSelferValueTypeArray1234 {
			yyl986 := r.ReadArrayStart()
			if yyl986 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl986, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys987Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys987Slc
	var yyhl987 bool = l >= 0
	for yyj987 := 0; ; yyj987++ {
		if yyhl987 {
			if yyj987 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys987Slc = r.DecodeBytes(yys987Slc, true, true)
		yys987 := string(yys987Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys987 {
		case "http":
			if r.TryDecodeAsNil() {
				if x.HTTP != nil {
					x.HTTP = nil
				}
			} else {
				if x.HTTP == nil {
					x.HTTP = new(HTTPIngressRuleValue)
				}
				x.HTTP.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys987)
		} // end switch yys987
	} // end for yyj987
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj989 int
	var yyb989 bool
	var yyhl989 bool = l >= 0
	yyj989++
	if yyhl989 {
		yyb989 = yyj989 > l
	} else {
		yyb989 = r.CheckBreak()
	}
	if yyb989 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj989++
		if yyhl989 {
			yyb989 = yyj989 > l
		} else {
			yyb989 = r.CheckBreak()
		}
		if yyb989 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj989-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym991 := z.EncBinary()
		_ = yym991
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep992 := !z.EncBinary()
			yy2arr992 := z.EncBasicHandle().StructToArray
			var yyq992 [1]bool
			_, _, _ = yysep992, yyq992, yy2arr992
			const yyr992 bool = false
			var yynn992 int
			if yyr992 || yy2arr992 {
				r.EncodeArrayStart(1)
			} else {
				yynn992 = 1
				for _, b := range yyq992 {
					if b {
						yynn992++
					}
				}
				r.EncodeMapStart(yynn992)
				yynn992 = 0
			}
			if yyr992 || yy2arr992 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym994 := z.EncBinary()
					_ = yym994
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym995 := z.EncBinary()
					_ = yym995
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr992 || yy2arr992 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym996 := z.DecBinary()
	_ = yym996
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct997 := r.ContainerType()
		if yyct997 == codecSelferValueTypeMap1234 {
			yyl997 := r.ReadMapStart()
			if yyl997 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl997, d)
			}
		} else if yyct997 == codecSelferValueTypeArray1234 {
			yyl997 := r.ReadArrayStart()
			if yyl997 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl997, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys998Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys998Slc
	var yyhl998 bool = l >= 0
	for yyj998 := 0; ; yyj998++ {
		if yyhl998 {
			if yyj998 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys998Slc = r.DecodeBytes(yys998Slc, true, true)
		yys998 := string(yys998Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys998 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv999 := &x.Paths
				yym1000 := z.DecBinary()
				_ = yym1000
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv999), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys998)
		} // end switch yys998
	} // end for yyj998
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1001 int
	var yyb1001 bool
	var yyhl1001 bool = l >= 0
	yyj1001++
	if yyhl1001 {
		yyb1001 = yyj1001 > l
	} else {
		yyb1001 = r.CheckBreak()
	}
	if yyb1001 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv1002 := &x.Paths
		yym1003 := z.DecBinary()
		_ = yym1003
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1002), d)
		}
	}
	for {
		yyj1001++
		if yyhl1001 {
			yyb1001 = yyj1001 > l
		} else {
			yyb1001 = r.CheckBreak()
		}
		if yyb1001 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1001-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1004 := z.EncBinary()
		_ = yym1004
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1005 := !z.EncBinary()
			yy2arr1005 := z.EncBasicHandle().StructToArray
			var yyq1005 [2]bool
			_, _, _ = yysep1005, yyq1005, yy2arr1005
			const yyr1005 bool = false
			yyq1005[0] = x.Path != ""
			var yynn1005 int
			if yyr1005 || yy2arr1005 {
				r.EncodeArrayStart(2)
			} else {
				yynn1005 = 1
				for _, b := range yyq1005 {
					if b {
						yynn1005++
					}
				}
				r.EncodeMapStart(yynn1005)
				yynn1005 = 0
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[0] {
					yym1007 := z.EncBinary()
					_ = yym1007
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1005[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1008 := z.EncBinary()
					_ = yym1008
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1010 := &x.Backend
				yy1010.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1011 := &x.Backend
				yy1011.CodecEncodeSelf(e)
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1012 := z.DecBinary()
	_ = yym1012
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1013 := r.ContainerType()
		if yyct1013 == codecSelferValueTypeMap1234 {
			yyl1013 := r.ReadMapStart()
			if yyl1013 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1013, d)
			}
		} else if yyct1013 == codecSelferValueTypeArray1234 {
			yyl1013 := r.ReadArrayStart()
			if yyl1013 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1013, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HTTPIngressPath) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1014Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1014Slc
	var yyhl1014 bool = l >= 0
	for yyj1014 := 0; ; yyj1014++ {
		if yyhl1014 {
			if yyj1014 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1014Slc = r.DecodeBytes(yys1014Slc, true, true)
		yys1014 := string(yys1014Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1014 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv1016 := &x.Backend
				yyv1016.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1014)
		} // end switch yys1014
	} // end for yyj1014
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1017 int
	var yyb1017 bool
	var yyhl1017 bool = l >= 0
	yyj1017++
	if yyhl1017 {
		yyb1017 = yyj1017 > l
	} else {
		yyb1017 = r.CheckBreak()
	}
	if yyb1017 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj1017++
	if yyhl1017 {
		yyb1017 = yyj1017 > l
	} else {
		yyb1017 = r.CheckBreak()
	}
	if yyb1017 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv1019 := &x.Backend
		yyv1019.CodecDecodeSelf(d)
	}
	for {
		yyj1017++
		if yyhl1017 {
			yyb1017 = yyj1017 > l
		} else {
			yyb1017 = r.CheckBreak()
		}
		if yyb1017 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1017-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1020 := z.EncBinary()
		_ = yym1020
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1021 := !z.EncBinary()
			yy2arr1021 := z.EncBasicHandle().StructToArray
			var yyq1021 [2]bool
			_, _, _ = yysep1021, yyq1021, yy2arr1021
			const yyr1021 bool = false
			var yynn1021 int
			if yyr1021 || yy2arr1021 {
				r.EncodeArrayStart(2)
			} else {
				yynn1021 = 2
				for _, b := range yyq1021 {
					if b {
						yynn1021++
					}
				}
				r.EncodeMapStart(yynn1021)
				yynn1021 = 0
			}
			if yyr1021 || yy2arr1021 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1023 := z.EncBinary()
				_ = yym1023
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1024 := z.EncBinary()
				_ = yym1024
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr1021 || yy2arr1021 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1026 := &x.ServicePort
				yym1027 := z.EncBinary()
				_ = yym1027
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1026) {
				} else if !yym1027 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1026)
				} else {
					z.EncFallback(yy1026)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1028 := &x.ServicePort
				yym1029 := z.EncBinary()
				_ = yym1029
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1028) {
				} else if !yym1029 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1028)
				} else {
					z.EncFallback(yy1028)
				}
			}
			if yyr1021 || yy2arr1021 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1030 := z.DecBinary()
	_ = yym1030
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1031 := r.ContainerType()
		if yyct1031 == codecSelferValueTypeMap1234 {
			yyl1031 := r.ReadMapStart()
			if yyl1031 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1031, d)
			}
		} else if yyct1031 == codecSelferValueTypeArray1234 {
			yyl1031 := r.ReadArrayStart()
			if yyl1031 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1031, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressBackend) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1032Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1032Slc
	var yyhl1032 bool = l >= 0
	for yyj1032 := 0; ; yyj1032++ {
		if yyhl1032 {
			if yyj1032 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1032Slc = r.DecodeBytes(yys1032Slc, true, true)
		yys1032 := string(yys1032Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1032 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg6_intstr.IntOrString{}
			} else {
				yyv1034 := &x.ServicePort
				yym1035 := z.DecBinary()
				_ = yym1035
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1034) {
				} else if !yym1035 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1034)
				} else {
					z.DecFallback(yyv1034, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1032)
		} // end switch yys1032
	} // end for yyj1032
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1036 int
	var yyb1036 bool
	var yyhl1036 bool = l >= 0
	yyj1036++
	if yyhl1036 {
		yyb1036 = yyj1036 > l
	} else {
		yyb1036 = r.CheckBreak()
	}
	if yyb1036 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj1036++
	if yyhl1036 {
		yyb1036 = yyj1036 > l
	} else {
		yyb1036 = r.CheckBreak()
	}
	if yyb1036 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg6_intstr.IntOrString{}
	} else {
		yyv1038 := &x.ServicePort
		yym1039 := z.DecBinary()
		_ = yym1039
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1038) {
		} else if !yym1039 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1038)
		} else {
			z.DecFallback(yyv1038, false)
		}
	}
	for {
		yyj1036++
		if yyhl1036 {
			yyb1036 = yyj1036 > l
		} else {
			yyb1036 = r.CheckBreak()
		}
		if yyb1036 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1036-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1040 := z.EncBinary()
	_ = yym1040
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *NodeResource) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1041 := z.DecBinary()
	_ = yym1041
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *NodeUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1042 := z.EncBinary()
		_ = yym1042
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1043 := !z.EncBinary()
			yy2arr1043 := z.EncBasicHandle().StructToArray
			var yyq1043 [2]bool
			_, _, _ = yysep1043, yyq1043, yy2arr1043
			const yyr1043 bool = false
			var yynn1043 int
			if yyr1043 || yy2arr1043 {
				r.EncodeArrayStart(2)
			} else {
				yynn1043 = 2
				for _, b := range yyq1043 {
					if b {
						yynn1043++
					}
				}
				r.EncodeMapStart(yynn1043)
				yynn1043 = 0
			}
			if yyr1043 || yy2arr1043 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Resource.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("resource"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Resource.CodecEncodeSelf(e)
			}
			if yyr1043 || yy2arr1043 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1046 := z.EncBinary()
				_ = yym1046
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1047 := z.EncBinary()
				_ = yym1047
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yyr1043 || yy2arr1043 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NodeUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1048 := z.DecBinary()
	_ = yym1048
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1049 := r.ContainerType()
		if yyct1049 == codecSelferValueTypeMap1234 {
			yyl1049 := r.ReadMapStart()
			if yyl1049 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1049, d)
			}
		} else if yyct1049 == codecSelferValueTypeArray1234 {
			yyl1049 := r.ReadArrayStart()
			if yyl1049 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1049, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NodeUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1050Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1050Slc
	var yyhl1050 bool = l >= 0
	for yyj1050 := 0; ; yyj1050++ {
		if yyhl1050 {
			if yyj1050 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1050Slc = r.DecodeBytes(yys1050Slc, true, true)
		yys1050 := string(yys1050Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1050 {
		case "resource":
			if r.TryDecodeAsNil() {
				x.Resource = ""
			} else {
				x.Resource = NodeResource(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.Value = 0
			} else {
				x.Value = float64(r.DecodeFloat(false))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1050)
		} // end switch yys1050
	} // end for yyj1050
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NodeUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1053 int
	var yyb1053 bool
	var yyhl1053 bool = l >= 0
	yyj1053++
	if yyhl1053 {
		yyb1053 = yyj1053 > l
	} else {
		yyb1053 = r.CheckBreak()
	}
	if yyb1053 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj1053++
	if yyhl1053 {
		yyb1053 = yyj1053 > l
	} else {
		yyb1053 = r.CheckBreak()
	}
	if yyb1053 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj1053++
		if yyhl1053 {
			yyb1053 = yyj1053 > l
		} else {
			yyb1053 = r.CheckBreak()
		}
		if yyb1053 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1053-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ClusterAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1056 := z.EncBinary()
		_ = yym1056
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1057 := !z.EncBinary()
			yy2arr1057 := z.EncBasicHandle().StructToArray
			var yyq1057 [3]bool
			_, _, _ = yysep1057, yyq1057, yy2arr1057
			const yyr1057 bool = false
			var yynn1057 int
			if yyr1057 || yy2arr1057 {
				r.EncodeArrayStart(3)
			} else {
				yynn1057 = 3
				for _, b := range yyq1057 {
					if b {
						yynn1057++
					}
				}
				r.EncodeMapStart(yynn1057)
				yynn1057 = 0
			}
			if yyr1057 || yy2arr1057 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1059 := z.EncBinary()
				_ = yym1059
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1060 := z.EncBinary()
				_ = yym1060
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1057 || yy2arr1057 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1062 := z.EncBinary()
				_ = yym1062
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1063 := z.EncBinary()
				_ = yym1063
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1057 || yy2arr1057 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1065 := z.EncBinary()
					_ = yym1065
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1066 := z.EncBinary()
					_ = yym1066
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yyr1057 || yy2arr1057 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ClusterAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1067 := z.DecBinary()
	_ = yym1067
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1068 := r.ContainerType()
		if yyct1068 == codecSelferValueTypeMap1234 {
			yyl1068 := r.ReadMapStart()
			if yyl1068 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1068, d)
			}
		} else if yyct1068 == codecSelferValueTypeArray1234 {
			yyl1068 := r.ReadArrayStart()
			if yyl1068 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1068, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1069Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1069Slc
	var yyhl1069 bool = l >= 0
	for yyj1069 := 0; ; yyj1069++ {
		if yyhl1069 {
			if yyj1069 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1069Slc = r.DecodeBytes(yys1069Slc, true, true)
		yys1069 := string(yys1069Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1069 {
		case "minNodes":
			if r.TryDecodeAsNil() {
				x.MinNodes = 0
			} else {
				x.MinNodes = int32(r.DecodeInt(32))
			}
		case "maxNodes":
			if r.TryDecodeAsNil() {
				x.MaxNodes = 0
			} else {
				x.MaxNodes = int32(r.DecodeInt(32))
			}
		case "target":
			if r.TryDecodeAsNil() {
				x.TargetUtilization = nil
			} else {
				yyv1072 := &x.TargetUtilization
				yym1073 := z.DecBinary()
				_ = yym1073
				if false {
				} else {
					h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1072), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1069)
		} // end switch yys1069
	} // end for yyj1069
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1074 int
	var yyb1074 bool
	var yyhl1074 bool = l >= 0
	yyj1074++
	if yyhl1074 {
		yyb1074 = yyj1074 > l
	} else {
		yyb1074 = r.CheckBreak()
	}
	if yyb1074 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int32(r.DecodeInt(32))
	}
	yyj1074++
	if yyhl1074 {
		yyb1074 = yyj1074 > l
	} else {
		yyb1074 = r.CheckBreak()
	}
	if yyb1074 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int32(r.DecodeInt(32))
	}
	yyj1074++
	if yyhl1074 {
		yyb1074 = yyj1074 > l
	} else {
		yyb1074 = r.CheckBreak()
	}
	if yyb1074 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1077 := &x.TargetUtilization
		yym1078 := z.DecBinary()
		_ = yym1078
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1077), d)
		}
	}
	for {
		yyj1074++
		if yyhl1074 {
			yyb1074 = yyj1074 > l
		} else {
			yyb1074 = r.CheckBreak()
		}
		if yyb1074 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1074-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ClusterAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1079 := z.EncBinary()
		_ = yym1079
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1080 := !z.EncBinary()
			yy2arr1080 := z.EncBasicHandle().StructToArray
			var yyq1080 [4]bool
			_, _, _ = yysep1080, yyq1080, yy2arr1080
			const yyr1080 bool = false
			yyq1080[0] = x.Kind != ""
			yyq1080[1] = x.APIVersion != ""
			yyq1080[2] = true
			yyq1080[3] = true
			var yynn1080 int
			if yyr1080 || yy2arr1080 {
				r.EncodeArrayStart(4)
			} else {
				yynn1080 = 0
				for _, b := range yyq1080 {
					if b {
						yynn1080++
					}
				}
				r.EncodeMapStart(yynn1080)
				yynn1080 = 0
			}
			if yyr1080 || yy2arr1080 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1080[0] {
					yym1082 := z.EncBinary()
					_ = yym1082
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1080[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1083 := z.EncBinary()
					_ = yym1083
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1080 || yy2arr1080 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1080[1] {
					yym1085 := z.EncBinary()
					_ = yym1085
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1080[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1086 := z.EncBinary()
					_ = yym1086
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1080 || yy2arr1080 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1080[2] {
					yy1088 := &x.ObjectMeta
					yy1088.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1080[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1089 := &x.ObjectMeta
					yy1089.CodecEncodeSelf(e)
				}
			}
			if yyr1080 || yy2arr1080 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1080[3] {
					yy1091 := &x.Spec
					yy1091.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1080[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1092 := &x.Spec
					yy1092.CodecEncodeSelf(e)
				}
			}
			if yyr1080 || yy2arr1080 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ClusterAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1093 := z.DecBinary()
	_ = yym1093
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1094 := r.ContainerType()
		if yyct1094 == codecSelferValueTypeMap1234 {
			yyl1094 := r.ReadMapStart()
			if yyl1094 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1094, d)
			}
		} else if yyct1094 == codecSelferValueTypeArray1234 {
			yyl1094 := r.ReadArrayStart()
			if yyl1094 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1094, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ClusterAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1095Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1095Slc
	var yyhl1095 bool = l >= 0
	for yyj1095 := 0; ; yyj1095++ {
		if yyhl1095 {
			if yyj1095 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1095Slc = r.DecodeBytes(yys1095Slc, true, true)
		yys1095 := string(yys1095Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1095 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1098 := &x.ObjectMeta
				yyv1098.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ClusterAutoscalerSpec{}
			} else {
				yyv1099 := &x.Spec
				yyv1099.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1095)
		} // end switch yys1095
	} // end for yyj1095
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1100 int
	var yyb1100 bool
	var yyhl1100 bool = l >= 0
	yyj1100++
	if yyhl1100 {
		yyb1100 = yyj1100 > l
	} else {
		yyb1100 = r.CheckBreak()
	}
	if yyb1100 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1100++
	if yyhl1100 {
		yyb1100 = yyj1100 > l
	} else {
		yyb1100 = r.CheckBreak()
	}
	if yyb1100 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1100++
	if yyhl1100 {
		yyb1100 = yyj1100 > l
	} else {
		yyb1100 = r.CheckBreak()
	}
	if yyb1100 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1103 := &x.ObjectMeta
		yyv1103.CodecDecodeSelf(d)
	}
	yyj1100++
	if yyhl1100 {
		yyb1100 = yyj1100 > l
	} else {
		yyb1100 = r.CheckBreak()
	}
	if yyb1100 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1104 := &x.Spec
		yyv1104.CodecDecodeSelf(d)
	}
	for {
		yyj1100++
		if yyhl1100 {
			yyb1100 = yyj1100 > l
		} else {
			yyb1100 = r.CheckBreak()
		}
		if yyb1100 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1100-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ClusterAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1105 := z.EncBinary()
		_ = yym1105
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1106 := !z.EncBinary()
			yy2arr1106 := z.EncBasicHandle().StructToArray
			var yyq1106 [4]bool
			_, _, _ = yysep1106, yyq1106, yy2arr1106
			const yyr1106 bool = false
			yyq1106[0] = x.Kind != ""
			yyq1106[1] = x.APIVersion != ""
			yyq1106[2] = true
			var yynn1106 int
			if yyr1106 || yy2arr1106 {
				r.EncodeArrayStart(4)
			} else {
				yynn1106 = 1
				for _, b := range yyq1106 {
					if b {
						yynn1106++
					}
				}
				r.EncodeMapStart(yynn1106)
				yynn1106 = 0
			}
			if yyr1106 || yy2arr1106 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1106[0] {
					yym1108 := z.EncBinary()
					_ = yym1108
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1106[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1109 := z.EncBinary()
					_ = yym1109
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1106 || yy2arr1106 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1106[1] {
					yym1111 := z.EncBinary()
					_ = yym1111
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1106[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1112 := z.EncBinary()
					_ = yym1112
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1106 || yy2arr1106 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1106[2] {
					yy1114 := &x.ListMeta
					yym1115 := z.EncBinary()
					_ = yym1115
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1114) {
					} else {
						z.EncFallback(yy1114)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1106[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1116 := &x.ListMeta
					yym1117 := z.EncBinary()
					_ = yym1117
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1116) {
					} else {
						z.EncFallback(yy1116)
					}
				}
			}
			if yyr1106 || yy2arr1106 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1119 := z.EncBinary()
					_ = yym1119
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1120 := z.EncBinary()
					_ = yym1120
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr1106 || yy2arr1106 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ClusterAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1121 := z.DecBinary()
	_ = yym1121
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1122 := r.ContainerType()
		if yyct1122 == codecSelferValueTypeMap1234 {
			yyl1122 := r.ReadMapStart()
			if yyl1122 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1122, d)
			}
		} else if yyct1122 == codecSelferValueTypeArray1234 {
			yyl1122 := r.ReadArrayStart()
			if yyl1122 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1122, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ClusterAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1123Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1123Slc
	var yyhl1123 bool = l >= 0
	for yyj1123 := 0; ; yyj1123++ {
		if yyhl1123 {
			if yyj1123 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1123Slc = r.DecodeBytes(yys1123Slc, true, true)
		yys1123 := string(yys1123Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1123 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1126 := &x.ListMeta
				yym1127 := z.DecBinary()
				_ = yym1127
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1126) {
				} else {
					z.DecFallback(yyv1126, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1128 := &x.Items
				yym1129 := z.DecBinary()
				_ = yym1129
				if false {
				} else {
					h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1128), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1123)
		} // end switch yys1123
	} // end for yyj1123
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1130 int
	var yyb1130 bool
	var yyhl1130 bool = l >= 0
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1133 := &x.ListMeta
		yym1134 := z.DecBinary()
		_ = yym1134
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1133) {
		} else {
			z.DecFallback(yyv1133, false)
		}
	}
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1135 := &x.Items
		yym1136 := z.DecBinary()
		_ = yym1136
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1135), d)
		}
	}
	for {
		yyj1130++
		if yyhl1130 {
			yyb1130 = yyj1130 > l
		} else {
			yyb1130 = r.CheckBreak()
		}
		if yyb1130 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1130-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1137 := z.EncBinary()
		_ = yym1137
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1138 := !z.EncBinary()
			yy2arr1138 := z.EncBasicHandle().StructToArray
			var yyq1138 [4]bool
			_, _, _ = yysep1138, yyq1138, yy2arr1138
			const yyr1138 bool = false
			yyq1138[0] = x.Kind != ""
			yyq1138[1] = x.APIVersion != ""
			var yynn1138 int
			if yyr1138 || yy2arr1138 {
				r.EncodeArrayStart(4)
			} else {
				yynn1138 = 2
				for _, b := range yyq1138 {
					if b {
						yynn1138++
					}
				}
				r.EncodeMapStart(yynn1138)
				yynn1138 = 0
			}
			if yyr1138 || yy2arr1138 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1138[0] {
					yym1140 := z.EncBinary()
					_ = yym1140
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1138[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1141 := z.EncBinary()
					_ = yym1141
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1138 || yy2arr1138 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1138[1] {
					yym1143 := z.EncBinary()
					_ = yym1143
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1138[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1144 := z.EncBinary()
					_ = yym1144
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1138 || yy2arr1138 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1146 := z.EncBinary()
				_ = yym1146
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("export"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1147 := z.EncBinary()
				_ = yym1147
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			}
			if yyr1138 || yy2arr1138 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1149 := z.EncBinary()
				_ = yym1149
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("exact"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1150 := z.EncBinary()
				_ = yym1150
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			}
			if yyr1138 || yy2arr1138 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ExportOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1151 := z.DecBinary()
	_ = yym1151
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1152 := r.ContainerType()
		if yyct1152 == codecSelferValueTypeMap1234 {
			yyl1152 := r.ReadMapStart()
			if yyl1152 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1152, d)
			}
		} else if yyct1152 == codecSelferValueTypeArray1234 {
			yyl1152 := r.ReadArrayStart()
			if yyl1152 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1152, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1153Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1153Slc
	var yyhl1153 bool = l >= 0
	for yyj1153 := 0; ; yyj1153++ {
		if yyhl1153 {
			if yyj1153 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1153Slc = r.DecodeBytes(yys1153Slc, true, true)
		yys1153 := string(yys1153Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1153 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "export":
			if r.TryDecodeAsNil() {
				x.Export = false
			} else {
				x.Export = bool(r.DecodeBool())
			}
		case "exact":
			if r.TryDecodeAsNil() {
				x.Exact = false
			} else {
				x.Exact = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1153)
		} // end switch yys1153
	} // end for yyj1153
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1158 int
	var yyb1158 bool
	var yyhl1158 bool = l >= 0
	yyj1158++
	if yyhl1158 {
		yyb1158 = yyj1158 > l
	} else {
		yyb1158 = r.CheckBreak()
	}
	if yyb1158 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1158++
	if yyhl1158 {
		yyb1158 = yyj1158 > l
	} else {
		yyb1158 = r.CheckBreak()
	}
	if yyb1158 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1158++
	if yyhl1158 {
		yyb1158 = yyj1158 > l
	} else {
		yyb1158 = r.CheckBreak()
	}
	if yyb1158 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Export = false
	} else {
		x.Export = bool(r.DecodeBool())
	}
	yyj1158++
	if yyhl1158 {
		yyb1158 = yyj1158 > l
	} else {
		yyb1158 = r.CheckBreak()
	}
	if yyb1158 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Exact = false
	} else {
		x.Exact = bool(r.DecodeBool())
	}
	for {
		yyj1158++
		if yyhl1158 {
			yyb1158 = yyj1158 > l
		} else {
			yyb1158 = r.CheckBreak()
		}
		if yyb1158 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1158-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1163 := z.EncBinary()
		_ = yym1163
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1164 := !z.EncBinary()
			yy2arr1164 := z.EncBasicHandle().StructToArray
			var yyq1164 [7]bool
			_, _, _ = yysep1164, yyq1164, yy2arr1164
			const yyr1164 bool = false
			yyq1164[0] = x.Kind != ""
			yyq1164[1] = x.APIVersion != ""
			yyq1164[2] = x.LabelSelector != ""
			yyq1164[3] = x.FieldSelector != ""
			yyq1164[4] = x.Watch != false
			yyq1164[5] = x.ResourceVersion != ""
			yyq1164[6] = x.TimeoutSeconds != nil
			var yynn1164 int
			if yyr1164 || yy2arr1164 {
				r.EncodeArrayStart(7)
			} else {
				yynn1164 = 0
				for _, b := range yyq1164 {
					if b {
						yynn1164++
					}
				}
				r.EncodeMapStart(yynn1164)
				yynn1164 = 0
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[0] {
					yym1166 := z.EncBinary()
					_ = yym1166
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1164[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1167 := z.EncBinary()
					_ = yym1167
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[1] {
					yym1169 := z.EncBinary()
					_ = yym1169
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1164[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1170 := z.EncBinary()
					_ = yym1170
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[2] {
					yym1172 := z.EncBinary()
					_ = yym1172
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1164[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1173 := z.EncBinary()
					_ = yym1173
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[3] {
					yym1175 := z.EncBinary()
					_ = yym1175
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1164[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fieldSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1176 := z.EncBinary()
					_ = yym1176
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[4] {
					yym1178 := z.EncBinary()
					_ = yym1178
					if false {
					} else {
						r.EncodeBool(bool(x.Watch))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1164[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("watch"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1179 := z.EncBinary()
					_ = yym1179
					if false {
					} else {
						r.EncodeBool(bool(x.Watch))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[5] {
					yym1181 := z.EncBinary()
					_ = yym1181
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1164[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("resourceVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1182 := z.EncBinary()
					_ = yym1182
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1164[6] {
					if x.TimeoutSeconds == nil {
						r.EncodeNil()
					} else {
						yy1184 := *x.TimeoutSeconds
						yym1185 := z.EncBinary()
						_ = yym1185
						if false {
						} else {
							r.EncodeInt(int64(yy1184))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1164[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("timeoutSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TimeoutSeconds == nil {
						r.EncodeNil()
					} else {
						yy1186 := *x.TimeoutSeconds
						yym1187 := z.EncBinary()
						_ = yym1187
						if false {
						} else {
							r.EncodeInt(int64(yy1186))
						}
					}
				}
			}
			if yyr1164 || yy2arr1164 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ListOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1188 := z.DecBinary()
	_ = yym1188
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1189 := r.ContainerType()
		if yyct1189 == codecSelferValueTypeMap1234 {
			yyl1189 := r.ReadMapStart()
			if yyl1189 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1189, d)
			}
		} else if yyct1189 == codecSelferValueTypeArray1234 {
			yyl1189 := r.ReadArrayStart()
			if yyl1189 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1189, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1190Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1190Slc
	var yyhl1190 bool = l >= 0
	for yyj1190 := 0; ; yyj1190++ {
		if yyhl1190 {
			if yyj1190 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1190Slc = r.DecodeBytes(yys1190Slc, true, true)
		yys1190 := string(yys1190Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1190 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "labelSelector":
			if r.TryDecodeAsNil() {
				x.LabelSelector = ""
			} else {
				x.LabelSelector = string(r.DecodeString())
			}
		case "fieldSelector":
			if r.TryDecodeAsNil() {
				x.FieldSelector = ""
			} else {
				x.FieldSelector = string(r.DecodeString())
			}
		case "watch":
			if r.TryDecodeAsNil() {
				x.Watch = false
			} else {
				x.Watch = bool(r.DecodeBool())
			}
		case "resourceVersion":
			if r.TryDecodeAsNil() {
				x.ResourceVersion = ""
			} else {
				x.ResourceVersion = string(r.DecodeString())
			}
		case "timeoutSeconds":
			if r.TryDecodeAsNil() {
				if x.TimeoutSeconds != nil {
					x.TimeoutSeconds = nil
				}
			} else {
				if x.TimeoutSeconds == nil {
					x.TimeoutSeconds = new(int64)
				}
				yym1198 := z.DecBinary()
				_ = yym1198
				if false {
				} else {
					*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1190)
		} // end switch yys1190
	} // end for yyj1190
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1199 int
	var yyb1199 bool
	var yyhl1199 bool = l >= 0
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LabelSelector = ""
	} else {
		x.LabelSelector = string(r.DecodeString())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FieldSelector = ""
	} else {
		x.FieldSelector = string(r.DecodeString())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Watch = false
	} else {
		x.Watch = bool(r.DecodeBool())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ResourceVersion = ""
	} else {
		x.ResourceVersion = string(r.DecodeString())
	}
	yyj1199++
	if yyhl1199 {
		yyb1199 = yyj1199 > l
	} else {
		yyb1199 = r.CheckBreak()
	}
	if yyb1199 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.TimeoutSeconds != nil {
			x.TimeoutSeconds = nil
		}
	} else {
		if x.TimeoutSeconds == nil {
			x.TimeoutSeconds = new(int64)
		}
		yym1207 := z.DecBinary()
		_ = yym1207
		if false {
		} else {
			*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
		}
	}
	for {
		yyj1199++
		if yyhl1199 {
			yyb1199 = yyj1199 > l
		} else {
			yyb1199 = r.CheckBreak()
		}
		if yyb1199 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1199-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *LabelSelector) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1208 := z.EncBinary()
		_ = yym1208
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1209 := !z.EncBinary()
			yy2arr1209 := z.EncBasicHandle().StructToArray
			var yyq1209 [2]bool
			_, _, _ = yysep1209, yyq1209, yy2arr1209
			const yyr1209 bool = false
			yyq1209[0] = len(x.MatchLabels) != 0
			yyq1209[1] = len(x.MatchExpressions) != 0
			var yynn1209 int
			if yyr1209 || yy2arr1209 {
				r.EncodeArrayStart(2)
			} else {
				yynn1209 = 0
				for _, b := range yyq1209 {
					if b {
						yynn1209++
					}
				}
				r.EncodeMapStart(yynn1209)
				yynn1209 = 0
			}
			if yyr1209 || yy2arr1209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1209[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1211 := z.EncBinary()
						_ = yym1211
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1209[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1212 := z.EncBinary()
						_ = yym1212
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1209 || yy2arr1209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1209[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1214 := z.EncBinary()
						_ = yym1214
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1209[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1215 := z.EncBinary()
						_ = yym1215
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yyr1209 || yy2arr1209 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *LabelSelector) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1216 := z.DecBinary()
	_ = yym1216
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1217 := r.ContainerType()
		if yyct1217 == codecSelferValueTypeMap1234 {
			yyl1217 := r.ReadMapStart()
			if yyl1217 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1217, d)
			}
		} else if yyct1217 == codecSelferValueTypeArray1234 {
			yyl1217 := r.ReadArrayStart()
			if yyl1217 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1217, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *LabelSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1218Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1218Slc
	var yyhl1218 bool = l >= 0
	for yyj1218 := 0; ; yyj1218++ {
		if yyhl1218 {
			if yyj1218 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1218Slc = r.DecodeBytes(yys1218Slc, true, true)
		yys1218 := string(yys1218Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1218 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1219 := &x.MatchLabels
				yym1220 := z.DecBinary()
				_ = yym1220
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1219, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1221 := &x.MatchExpressions
				yym1222 := z.DecBinary()
				_ = yym1222
				if false {
				} else {
					h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1221), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1218)
		} // end switch yys1218
	} // end for yyj1218
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *LabelSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1223 int
	var yyb1223 bool
	var yyhl1223 bool = l >= 0
	yyj1223++
	if yyhl1223 {
		yyb1223 = yyj1223 > l
	} else {
		yyb1223 = r.CheckBreak()
	}
	if yyb1223 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1224 := &x.MatchLabels
		yym1225 := z.DecBinary()
		_ = yym1225
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1224, false, d)
		}
	}
	yyj1223++
	if yyhl1223 {
		yyb1223 = yyj1223 > l
	} else {
		yyb1223 = r.CheckBreak()
	}
	if yyb1223 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1226 := &x.MatchExpressions
		yym1227 := z.DecBinary()
		_ = yym1227
		if false {
		} else {
			h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1226), d)
		}
	}
	for {
		yyj1223++
		if yyhl1223 {
			yyb1223 = yyj1223 > l
		} else {
			yyb1223 = r.CheckBreak()
		}
		if yyb1223 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1223-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *LabelSelectorRequirement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1228 := z.EncBinary()
		_ = yym1228
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1229 := !z.EncBinary()
			yy2arr1229 := z.EncBasicHandle().StructToArray
			var yyq1229 [3]bool
			_, _, _ = yysep1229, yyq1229, yy2arr1229
			const yyr1229 bool = false
			yyq1229[2] = len(x.Values) != 0
			var yynn1229 int
			if yyr1229 || yy2arr1229 {
				r.EncodeArrayStart(3)
			} else {
				yynn1229 = 2
				for _, b := range yyq1229 {
					if b {
						yynn1229++
					}
				}
				r.EncodeMapStart(yynn1229)
				yynn1229 = 0
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1231 := z.EncBinary()
				_ = yym1231
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1232 := z.EncBinary()
				_ = yym1232
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Operator.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1235 := z.EncBinary()
						_ = yym1235
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1229[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1236 := z.EncBinary()
						_ = yym1236
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *LabelSelectorRequirement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1237 := z.DecBinary()
	_ = yym1237
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1238 := r.ContainerType()
		if yyct1238 == codecSelferValueTypeMap1234 {
			yyl1238 := r.ReadMapStart()
			if yyl1238 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1238, d)
			}
		} else if yyct1238 == codecSelferValueTypeArray1234 {
			yyl1238 := r.ReadArrayStart()
			if yyl1238 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1238, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *LabelSelectorRequirement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1239Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1239Slc
	var yyhl1239 bool = l >= 0
	for yyj1239 := 0; ; yyj1239++ {
		if yyhl1239 {
			if yyj1239 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1239Slc = r.DecodeBytes(yys1239Slc, true, true)
		yys1239 := string(yys1239Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1239 {
		case "key":
			if r.TryDecodeAsNil() {
				x.Key = ""
			} else {
				x.Key = string(r.DecodeString())
			}
		case "operator":
			if r.TryDecodeAsNil() {
				x.Operator = ""
			} else {
				x.Operator = LabelSelectorOperator(r.DecodeString())
			}
		case "values":
			if r.TryDecodeAsNil() {
				x.Values = nil
			} else {
				yyv1242 := &x.Values
				yym1243 := z.DecBinary()
				_ = yym1243
				if false {
				} else {
					z.F.DecSliceStringX(yyv1242, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1239)
		} // end switch yys1239
	} // end for yyj1239
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *LabelSelectorRequirement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1244 int
	var yyb1244 bool
	var yyhl1244 bool = l >= 0
	yyj1244++
	if yyhl1244 {
		yyb1244 = yyj1244 > l
	} else {
		yyb1244 = r.CheckBreak()
	}
	if yyb1244 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1244++
	if yyhl1244 {
		yyb1244 = yyj1244 > l
	} else {
		yyb1244 = r.CheckBreak()
	}
	if yyb1244 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = LabelSelectorOperator(r.DecodeString())
	}
	yyj1244++
	if yyhl1244 {
		yyb1244 = yyj1244 > l
	} else {
		yyb1244 = r.CheckBreak()
	}
	if yyb1244 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1247 := &x.Values
		yym1248 := z.DecBinary()
		_ = yym1248
		if false {
		} else {
			z.F.DecSliceStringX(yyv1247, false, d)
		}
	}
	for {
		yyj1244++
		if yyhl1244 {
			yyb1244 = yyj1244 > l
		} else {
			yyb1244 = r.CheckBreak()
		}
		if yyb1244 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1244-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1249 := z.EncBinary()
	_ = yym1249
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *LabelSelectorOperator) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1250 := z.DecBinary()
	_ = yym1250
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1251 := z.EncBinary()
		_ = yym1251
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1252 := !z.EncBinary()
			yy2arr1252 := z.EncBasicHandle().StructToArray
			var yyq1252 [4]bool
			_, _, _ = yysep1252, yyq1252, yy2arr1252
			const yyr1252 bool = false
			yyq1252[0] = x.Kind != ""
			yyq1252[1] = x.APIVersion != ""
			yyq1252[2] = true
			yyq1252[3] = len(x.Data) != 0
			var yynn1252 int
			if yyr1252 || yy2arr1252 {
				r.EncodeArrayStart(4)
			} else {
				yynn1252 = 0
				for _, b := range yyq1252 {
					if b {
						yynn1252++
					}
				}
				r.EncodeMapStart(yynn1252)
				yynn1252 = 0
			}
			if yyr1252 || yy2arr1252 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1252[0] {
					yym1254 := z.EncBinary()
					_ = yym1254
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1252[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1255 := z.EncBinary()
					_ = yym1255
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1252 || yy2arr1252 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1252[1] {
					yym1257 := z.EncBinary()
					_ = yym1257
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1252[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1258 := z.EncBinary()
					_ = yym1258
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1252 || yy2arr1252 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1252[2] {
					yy1260 := &x.ObjectMeta
					yy1260.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1252[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1261 := &x.ObjectMeta
					yy1261.CodecEncodeSelf(e)
				}
			}
			if yyr1252 || yy2arr1252 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1252[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym1263 := z.EncBinary()
						_ = yym1263
						if false {
						} else {
							z.F.EncMapStringStringV(x.Data, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1252[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym1264 := z.EncBinary()
						_ = yym1264
						if false {
						} else {
							z.F.EncMapStringStringV(x.Data, false, e)
						}
					}
				}
			}
			if yyr1252 || yy2arr1252 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ConfigMap) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1265 := z.DecBinary()
	_ = yym1265
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1266 := r.ContainerType()
		if yyct1266 == codecSelferValueTypeMap1234 {
			yyl1266 := r.ReadMapStart()
			if yyl1266 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1266, d)
			}
		} else if yyct1266 == codecSelferValueTypeArray1234 {
			yyl1266 := r.ReadArrayStart()
			if yyl1266 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1266, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1267Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1267Slc
	var yyhl1267 bool = l >= 0
	for yyj1267 := 0; ; yyj1267++ {
		if yyhl1267 {
			if yyj1267 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1267Slc = r.DecodeBytes(yys1267Slc, true, true)
		yys1267 := string(yys1267Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1267 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1270 := &x.ObjectMeta
				yyv1270.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv1271 := &x.Data
				yym1272 := z.DecBinary()
				_ = yym1272
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1271, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1267)
		} // end switch yys1267
	} // end for yyj1267
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1273 int
	var yyb1273 bool
	var yyhl1273 bool = l >= 0
	yyj1273++
	if yyhl1273 {
		yyb1273 = yyj1273 > l
	} else {
		yyb1273 = r.CheckBreak()
	}
	if yyb1273 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1273++
	if yyhl1273 {
		yyb1273 = yyj1273 > l
	} else {
		yyb1273 = r.CheckBreak()
	}
	if yyb1273 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1273++
	if yyhl1273 {
		yyb1273 = yyj1273 > l
	} else {
		yyb1273 = r.CheckBreak()
	}
	if yyb1273 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1276 := &x.ObjectMeta
		yyv1276.CodecDecodeSelf(d)
	}
	yyj1273++
	if yyhl1273 {
		yyb1273 = yyj1273 > l
	} else {
		yyb1273 = r.CheckBreak()
	}
	if yyb1273 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv1277 := &x.Data
		yym1278 := z.DecBinary()
		_ = yym1278
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1277, false, d)
		}
	}
	for {
		yyj1273++
		if yyhl1273 {
			yyb1273 = yyj1273 > l
		} else {
			yyb1273 = r.CheckBreak()
		}
		if yyb1273 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1273-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1279 := z.EncBinary()
		_ = yym1279
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1280 := !z.EncBinary()
			yy2arr1280 := z.EncBasicHandle().StructToArray
			var yyq1280 [4]bool
			_, _, _ = yysep1280, yyq1280, yy2arr1280
			const yyr1280 bool = false
			yyq1280[0] = x.Kind != ""
			yyq1280[1] = x.APIVersion != ""
			yyq1280[2] = true
			yyq1280[3] = len(x.Items) != 0
			var yynn1280 int
			if yyr1280 || yy2arr1280 {
				r.EncodeArrayStart(4)
			} else {
				yynn1280 = 0
				for _, b := range yyq1280 {
					if b {
						yynn1280++
					}
				}
				r.EncodeMapStart(yynn1280)
				yynn1280 = 0
			}
			if yyr1280 || yy2arr1280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1280[0] {
					yym1282 := z.EncBinary()
					_ = yym1282
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1280[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1283 := z.EncBinary()
					_ = yym1283
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1280 || yy2arr1280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1280[1] {
					yym1285 := z.EncBinary()
					_ = yym1285
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1280[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1286 := z.EncBinary()
					_ = yym1286
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1280 || yy2arr1280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1280[2] {
					yy1288 := &x.ListMeta
					yym1289 := z.EncBinary()
					_ = yym1289
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1288) {
					} else {
						z.EncFallback(yy1288)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1280[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1290 := &x.ListMeta
					yym1291 := z.EncBinary()
					_ = yym1291
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1290) {
					} else {
						z.EncFallback(yy1290)
					}
				}
			}
			if yyr1280 || yy2arr1280 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1280[3] {
					if x.Items == nil {
						r.EncodeNil()
					} else {
						yym1293 := z.EncBinary()
						_ = yym1293
						if false {
						} else {
							h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1280[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("items"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Items == nil {
						r.EncodeNil()
					} else {
						yym1294 := z.EncBinary()
						_ = yym1294
						if false {
						} else {
							h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
						}
					}
				}
			}
			if yyr1280 || yy2arr1280 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ConfigMapList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1295 := z.DecBinary()
	_ = yym1295
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1296 := r.ContainerType()
		if yyct1296 == codecSelferValueTypeMap1234 {
			yyl1296 := r.ReadMapStart()
			if yyl1296 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1296, d)
			}
		} else if yyct1296 == codecSelferValueTypeArray1234 {
			yyl1296 := r.ReadArrayStart()
			if yyl1296 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1296, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1297Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1297Slc
	var yyhl1297 bool = l >= 0
	for yyj1297 := 0; ; yyj1297++ {
		if yyhl1297 {
			if yyj1297 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1297Slc = r.DecodeBytes(yys1297Slc, true, true)
		yys1297 := string(yys1297Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1297 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1300 := &x.ListMeta
				yym1301 := z.DecBinary()
				_ = yym1301
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1300) {
				} else {
					z.DecFallback(yyv1300, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1302 := &x.Items
				yym1303 := z.DecBinary()
				_ = yym1303
				if false {
				} else {
					h.decSliceConfigMap((*[]ConfigMap)(yyv1302), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1297)
		} // end switch yys1297
	} // end for yyj1297
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1304 int
	var yyb1304 bool
	var yyhl1304 bool = l >= 0
	yyj1304++
	if yyhl1304 {
		yyb1304 = yyj1304 > l
	} else {
		yyb1304 = r.CheckBreak()
	}
	if yyb1304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1304++
	if yyhl1304 {
		yyb1304 = yyj1304 > l
	} else {
		yyb1304 = r.CheckBreak()
	}
	if yyb1304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1304++
	if yyhl1304 {
		yyb1304 = yyj1304 > l
	} else {
		yyb1304 = r.CheckBreak()
	}
	if yyb1304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1307 := &x.ListMeta
		yym1308 := z.DecBinary()
		_ = yym1308
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1307) {
		} else {
			z.DecFallback(yyv1307, false)
		}
	}
	yyj1304++
	if yyhl1304 {
		yyb1304 = yyj1304 > l
	} else {
		yyb1304 = r.CheckBreak()
	}
	if yyb1304 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1309 := &x.Items
		yym1310 := z.DecBinary()
		_ = yym1310
		if false {
		} else {
			h.decSliceConfigMap((*[]ConfigMap)(yyv1309), d)
		}
	}
	for {
		yyj1304++
		if yyhl1304 {
			yyb1304 = yyj1304 > l
		} else {
			yyb1304 = r.CheckBreak()
		}
		if yyb1304 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1304-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1311 := z.EncBinary()
		_ = yym1311
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1312 := !z.EncBinary()
			yy2arr1312 := z.EncBasicHandle().StructToArray
			var yyq1312 [5]bool
			_, _, _ = yysep1312, yyq1312, yy2arr1312
			const yyr1312 bool = false
			yyq1312[0] = x.Kind != ""
			yyq1312[1] = x.APIVersion != ""
			yyq1312[2] = true
			yyq1312[3] = true
			yyq1312[4] = true
			var yynn1312 int
			if yyr1312 || yy2arr1312 {
				r.EncodeArrayStart(5)
			} else {
				yynn1312 = 0
				for _, b := range yyq1312 {
					if b {
						yynn1312++
					}
				}
				r.EncodeMapStart(yynn1312)
				yynn1312 = 0
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1312[0] {
					yym1314 := z.EncBinary()
					_ = yym1314
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1312[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1315 := z.EncBinary()
					_ = yym1315
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1312[1] {
					yym1317 := z.EncBinary()
					_ = yym1317
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1312[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1318 := z.EncBinary()
					_ = yym1318
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1312[2] {
					yy1320 := &x.ObjectMeta
					yy1320.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1312[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1321 := &x.ObjectMeta
					yy1321.CodecEncodeSelf(e)
				}
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1312[3] {
					yy1323 := &x.Spec
					yy1323.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1312[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1324 := &x.Spec
					yy1324.CodecEncodeSelf(e)
				}
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1312[4] {
					yy1326 := &x.Status
					yy1326.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1312[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1327 := &x.Status
					yy1327.CodecEncodeSelf(e)
				}
			}
			if yyr1312 || yy2arr1312 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1328 := z.DecBinary()
	_ = yym1328
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1329 := r.ContainerType()
		if yyct1329 == codecSelferValueTypeMap1234 {
			yyl1329 := r.ReadMapStart()
			if yyl1329 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1329, d)
			}
		} else if yyct1329 == codecSelferValueTypeArray1234 {
			yyl1329 := r.ReadArrayStart()
			if yyl1329 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1329, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1330Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1330Slc
	var yyhl1330 bool = l >= 0
	for yyj1330 := 0; ; yyj1330++ {
		if yyhl1330 {
			if yyj1330 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1330Slc = r.DecodeBytes(yys1330Slc, true, true)
		yys1330 := string(yys1330Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1330 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1333 := &x.ObjectMeta
				yyv1333.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv1334 := &x.Spec
				yyv1334.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv1335 := &x.Status
				yyv1335.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1330)
		} // end switch yys1330
	} // end for yyj1330
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1336 int
	var yyb1336 bool
	var yyhl1336 bool = l >= 0
	yyj1336++
	if yyhl1336 {
		yyb1336 = yyj1336 > l
	} else {
		yyb1336 = r.CheckBreak()
	}
	if yyb1336 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1336++
	if yyhl1336 {
		yyb1336 = yyj1336 > l
	} else {
		yyb1336 = r.CheckBreak()
	}
	if yyb1336 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1336++
	if yyhl1336 {
		yyb1336 = yyj1336 > l
	} else {
		yyb1336 = r.CheckBreak()
	}
	if yyb1336 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1339 := &x.ObjectMeta
		yyv1339.CodecDecodeSelf(d)
	}
	yyj1336++
	if yyhl1336 {
		yyb1336 = yyj1336 > l
	} else {
		yyb1336 = r.CheckBreak()
	}
	if yyb1336 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv1340 := &x.Spec
		yyv1340.CodecDecodeSelf(d)
	}
	yyj1336++
	if yyhl1336 {
		yyb1336 = yyj1336 > l
	} else {
		yyb1336 = r.CheckBreak()
	}
	if yyb1336 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv1341 := &x.Status
		yyv1341.CodecDecodeSelf(d)
	}
	for {
		yyj1336++
		if yyhl1336 {
			yyb1336 = yyj1336 > l
		} else {
			yyb1336 = r.CheckBreak()
		}
		if yyb1336 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1336-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1342 := z.EncBinary()
		_ = yym1342
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1343 := !z.EncBinary()
			yy2arr1343 := z.EncBasicHandle().StructToArray
			var yyq1343 [4]bool
			_, _, _ = yysep1343, yyq1343, yy2arr1343
			const yyr1343 bool = false
			yyq1343[0] = x.Kind != ""
			yyq1343[1] = x.APIVersion != ""
			yyq1343[2] = true
			var yynn1343 int
			if yyr1343 || yy2arr1343 {
				r.EncodeArrayStart(4)
			} else {
				yynn1343 = 1
				for _, b := range yyq1343 {
					if b {
						yynn1343++
					}
				}
				r.EncodeMapStart(yynn1343)
				yynn1343 = 0
			}
			if yyr1343 || yy2arr1343 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1343[0] {
					yym1345 := z.EncBinary()
					_ = yym1345
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1343[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1346 := z.EncBinary()
					_ = yym1346
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1343 || yy2arr1343 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1343[1] {
					yym1348 := z.EncBinary()
					_ = yym1348
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1343[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1349 := z.EncBinary()
					_ = yym1349
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1343 || yy2arr1343 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1343[2] {
					yy1351 := &x.ListMeta
					yym1352 := z.EncBinary()
					_ = yym1352
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1351) {
					} else {
						z.EncFallback(yy1351)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1343[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1353 := &x.ListMeta
					yym1354 := z.EncBinary()
					_ = yym1354
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1353) {
					} else {
						z.EncFallback(yy1353)
					}
				}
			}
			if yyr1343 || yy2arr1343 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1356 := z.EncBinary()
					_ = yym1356
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1357 := z.EncBinary()
					_ = yym1357
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr1343 || yy2arr1343 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1358 := z.DecBinary()
	_ = yym1358
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1359 := r.ContainerType()
		if yyct1359 == codecSelferValueTypeMap1234 {
			yyl1359 := r.ReadMapStart()
			if yyl1359 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1359, d)
			}
		} else if yyct1359 == codecSelferValueTypeArray1234 {
			yyl1359 := r.ReadArrayStart()
			if yyl1359 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1359, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1360Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1360Slc
	var yyhl1360 bool = l >= 0
	for yyj1360 := 0; ; yyj1360++ {
		if yyhl1360 {
			if yyj1360 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1360Slc = r.DecodeBytes(yys1360Slc, true, true)
		yys1360 := string(yys1360Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1360 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1363 := &x.ListMeta
				yym1364 := z.DecBinary()
				_ = yym1364
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1363) {
				} else {
					z.DecFallback(yyv1363, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1365 := &x.Items
				yym1366 := z.DecBinary()
				_ = yym1366
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv1365), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1360)
		} // end switch yys1360
	} // end for yyj1360
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1367 int
	var yyb1367 bool
	var yyhl1367 bool = l >= 0
	yyj1367++
	if yyhl1367 {
		yyb1367 = yyj1367 > l
	} else {
		yyb1367 = r.CheckBreak()
	}
	if yyb1367 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1367++
	if yyhl1367 {
		yyb1367 = yyj1367 > l
	} else {
		yyb1367 = r.CheckBreak()
	}
	if yyb1367 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1367++
	if yyhl1367 {
		yyb1367 = yyj1367 > l
	} else {
		yyb1367 = r.CheckBreak()
	}
	if yyb1367 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1370 := &x.ListMeta
		yym1371 := z.DecBinary()
		_ = yym1371
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1370) {
		} else {
			z.DecFallback(yyv1370, false)
		}
	}
	yyj1367++
	if yyhl1367 {
		yyb1367 = yyj1367 > l
	} else {
		yyb1367 = r.CheckBreak()
	}
	if yyb1367 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1372 := &x.Items
		yym1373 := z.DecBinary()
		_ = yym1373
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv1372), d)
		}
	}
	for {
		yyj1367++
		if yyhl1367 {
			yyb1367 = yyj1367 > l
		} else {
			yyb1367 = r.CheckBreak()
		}
		if yyb1367 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1367-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1374 := z.EncBinary()
		_ = yym1374
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1375 := !z.EncBinary()
			yy2arr1375 := z.EncBasicHandle().StructToArray
			var yyq1375 [3]bool
			_, _, _ = yysep1375, yyq1375, yy2arr1375
			const yyr1375 bool = false
			yyq1375[0] = x.Replicas != nil
			yyq1375[1] = x.Selector != nil
			yyq1375[2] = x.Template != nil
			var yynn1375 int
			if yyr1375 || yy2arr1375 {
				r.EncodeArrayStart(3)
			} else {
				yynn1375 = 0
				for _, b := range yyq1375 {
					if b {
						yynn1375++
					}
				}
				r.EncodeMapStart(yynn1375)
				yynn1375 = 0
			}
			if yyr1375 || yy2arr1375 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1375[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1377 := *x.Replicas
						yym1378 := z.EncBinary()
						_ = yym1378
						if false {
						} else {
							r.EncodeInt(int64(yy1377))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1375[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1379 := *x.Replicas
						yym1380 := z.EncBinary()
						_ = yym1380
						if false {
						} else {
							r.EncodeInt(int64(yy1379))
						}
					}
				}
			}
			if yyr1375 || yy2arr1375 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1375[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1375[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1375 || yy2arr1375 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1375[2] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1375[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1375 || yy2arr1375 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1383 := z.DecBinary()
	_ = yym1383
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1384 := r.ContainerType()
		if yyct1384 == codecSelferValueTypeMap1234 {
			yyl1384 := r.ReadMapStart()
			if yyl1384 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1384, d)
			}
		} else if yyct1384 == codecSelferValueTypeArray1234 {
			yyl1384 := r.ReadArrayStart()
			if yyl1384 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1384, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1385Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1385Slc
	var yyhl1385 bool = l >= 0
	for yyj1385 := 0; ; yyj1385++ {
		if yyhl1385 {
			if yyj1385 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1385Slc = r.DecodeBytes(yys1385Slc, true, true)
		yys1385 := string(yys1385Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1385 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym1387 := z.DecBinary()
				_ = yym1387
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				if x.Template != nil {
					x.Template = nil
				}
			} else {
				if x.Template == nil {
					x.Template = new(pkg2_v1.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1385)
		} // end switch yys1385
	} // end for yyj1385
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1390 int
	var yyb1390 bool
	var yyhl1390 bool = l >= 0
	yyj1390++
	if yyhl1390 {
		yyb1390 = yyj1390 > l
	} else {
		yyb1390 = r.CheckBreak()
	}
	if yyb1390 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym1392 := z.DecBinary()
		_ = yym1392
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj1390++
	if yyhl1390 {
		yyb1390 = yyj1390 > l
	} else {
		yyb1390 = r.CheckBreak()
	}
	if yyb1390 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj1390++
	if yyhl1390 {
		yyb1390 = yyj1390 > l
	} else {
		yyb1390 = r.CheckBreak()
	}
	if yyb1390 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_v1.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj1390++
		if yyhl1390 {
			yyb1390 = yyj1390 > l
		} else {
			yyb1390 = r.CheckBreak()
		}
		if yyb1390 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1390-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1395 := z.EncBinary()
		_ = yym1395
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1396 := !z.EncBinary()
			yy2arr1396 := z.EncBasicHandle().StructToArray
			var yyq1396 [2]bool
			_, _, _ = yysep1396, yyq1396, yy2arr1396
			const yyr1396 bool = false
			yyq1396[1] = x.ObservedGeneration != 0
			var yynn1396 int
			if yyr1396 || yy2arr1396 {
				r.EncodeArrayStart(2)
			} else {
				yynn1396 = 1
				for _, b := range yyq1396 {
					if b {
						yynn1396++
					}
				}
				r.EncodeMapStart(yynn1396)
				yynn1396 = 0
			}
			if yyr1396 || yy2arr1396 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1398 := z.EncBinary()
				_ = yym1398
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1399 := z.EncBinary()
				_ = yym1399
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1396 || yy2arr1396 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1396[1] {
					yym1401 := z.EncBinary()
					_ = yym1401
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1396[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1402 := z.EncBinary()
					_ = yym1402
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr1396 || yy2arr1396 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1403 := z.DecBinary()
	_ = yym1403
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1404 := r.ContainerType()
		if yyct1404 == codecSelferValueTypeMap1234 {
			yyl1404 := r.ReadMapStart()
			if yyl1404 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1404, d)
			}
		} else if yyct1404 == codecSelferValueTypeArray1234 {
			yyl1404 := r.ReadArrayStart()
			if yyl1404 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1404, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1405Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1405Slc
	var yyhl1405 bool = l >= 0
	for yyj1405 := 0; ; yyj1405++ {
		if yyhl1405 {
			if yyj1405 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1405Slc = r.DecodeBytes(yys1405Slc, true, true)
		yys1405 := string(yys1405Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1405 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1405)
		} // end switch yys1405
	} // end for yyj1405
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1408 int
	var yyb1408 bool
	var yyhl1408 bool = l >= 0
	yyj1408++
	if yyhl1408 {
		yyb1408 = yyj1408 > l
	} else {
		yyb1408 = r.CheckBreak()
	}
	if yyb1408 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj1408++
	if yyhl1408 {
		yyb1408 = yyj1408 > l
	} else {
		yyb1408 = r.CheckBreak()
	}
	if yyb1408 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	for {
		yyj1408++
		if yyhl1408 {
			yyb1408 = yyj1408 > l
		} else {
			yyb1408 = r.CheckBreak()
		}
		if yyb1408 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1408-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) encSliceHorizontalPodAutoscaler(v []HorizontalPodAutoscaler, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1411 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1412 := &yyv1411
		yy1412.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceHorizontalPodAutoscaler(v *[]HorizontalPodAutoscaler, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1413 := *v
	yyh1413, yyl1413 := z.DecSliceHelperStart()
	var yyc1413 bool
	if yyl1413 == 0 {
		if yyv1413 == nil {
			yyv1413 = []HorizontalPodAutoscaler{}
			yyc1413 = true
		} else if len(yyv1413) != 0 {
			yyv1413 = yyv1413[:0]
			yyc1413 = true
		}
	} else if yyl1413 > 0 {
		var yyrr1413, yyrl1413 int
		var yyrt1413 bool
		if yyl1413 > cap(yyv1413) {

			yyrg1413 := len(yyv1413) > 0
			yyv21413 := yyv1413
			yyrl1413, yyrt1413 = z.DecInferLen(yyl1413, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1413 {
				if yyrl1413 <= cap(yyv1413) {
					yyv1413 = yyv1413[:yyrl1413]
				} else {
					yyv1413 = make([]HorizontalPodAutoscaler, yyrl1413)
				}
			} else {
				yyv1413 = make([]HorizontalPodAutoscaler, yyrl1413)
			}
			yyc1413 = true
			yyrr1413 = len(yyv1413)
			if yyrg1413 {
				copy(yyv1413, yyv21413)
			}
		} else if yyl1413 != len(yyv1413) {
			yyv1413 = yyv1413[:yyl1413]
			yyc1413 = true
		}
		yyj1413 := 0
		for ; yyj1413 < yyrr1413; yyj1413++ {
			yyh1413.ElemContainerState(yyj1413)
			if r.TryDecodeAsNil() {
				yyv1413[yyj1413] = HorizontalPodAutoscaler{}
			} else {
				yyv1414 := &yyv1413[yyj1413]
				yyv1414.CodecDecodeSelf(d)
			}

		}
		if yyrt1413 {
			for ; yyj1413 < yyl1413; yyj1413++ {
				yyv1413 = append(yyv1413, HorizontalPodAutoscaler{})
				yyh1413.ElemContainerState(yyj1413)
				if r.TryDecodeAsNil() {
					yyv1413[yyj1413] = HorizontalPodAutoscaler{}
				} else {
					yyv1415 := &yyv1413[yyj1413]
					yyv1415.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1413 := 0
		for ; !r.CheckBreak(); yyj1413++ {

			if yyj1413 >= len(yyv1413) {
				yyv1413 = append(yyv1413, HorizontalPodAutoscaler{}) // var yyz1413 HorizontalPodAutoscaler
				yyc1413 = true
			}
			yyh1413.ElemContainerState(yyj1413)
			if yyj1413 < len(yyv1413) {
				if r.TryDecodeAsNil() {
					yyv1413[yyj1413] = HorizontalPodAutoscaler{}
				} else {
					yyv1416 := &yyv1413[yyj1413]
					yyv1416.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1413 < len(yyv1413) {
			yyv1413 = yyv1413[:yyj1413]
			yyc1413 = true
		} else if yyj1413 == 0 && yyv1413 == nil {
			yyv1413 = []HorizontalPodAutoscaler{}
			yyc1413 = true
		}
	}
	yyh1413.End()
	if yyc1413 {
		*v = yyv1413
	}
}

func (x codecSelfer1234) encSliceAPIVersion(v []APIVersion, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1417 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1418 := &yyv1417
		yy1418.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceAPIVersion(v *[]APIVersion, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1419 := *v
	yyh1419, yyl1419 := z.DecSliceHelperStart()
	var yyc1419 bool
	if yyl1419 == 0 {
		if yyv1419 == nil {
			yyv1419 = []APIVersion{}
			yyc1419 = true
		} else if len(yyv1419) != 0 {
			yyv1419 = yyv1419[:0]
			yyc1419 = true
		}
	} else if yyl1419 > 0 {
		var yyrr1419, yyrl1419 int
		var yyrt1419 bool
		if yyl1419 > cap(yyv1419) {

			yyrg1419 := len(yyv1419) > 0
			yyv21419 := yyv1419
			yyrl1419, yyrt1419 = z.DecInferLen(yyl1419, z.DecBasicHandle().MaxInitLen, 32)
			if yyrt1419 {
				if yyrl1419 <= cap(yyv1419) {
					yyv1419 = yyv1419[:yyrl1419]
				} else {
					yyv1419 = make([]APIVersion, yyrl1419)
				}
			} else {
				yyv1419 = make([]APIVersion, yyrl1419)
			}
			yyc1419 = true
			yyrr1419 = len(yyv1419)
			if yyrg1419 {
				copy(yyv1419, yyv21419)
			}
		} else if yyl1419 != len(yyv1419) {
			yyv1419 = yyv1419[:yyl1419]
			yyc1419 = true
		}
		yyj1419 := 0
		for ; yyj1419 < yyrr1419; yyj1419++ {
			yyh1419.ElemContainerState(yyj1419)
			if r.TryDecodeAsNil() {
				yyv1419[yyj1419] = APIVersion{}
			} else {
				yyv1420 := &yyv1419[yyj1419]
				yyv1420.CodecDecodeSelf(d)
			}

		}
		if yyrt1419 {
			for ; yyj1419 < yyl1419; yyj1419++ {
				yyv1419 = append(yyv1419, APIVersion{})
				yyh1419.ElemContainerState(yyj1419)
				if r.TryDecodeAsNil() {
					yyv1419[yyj1419] = APIVersion{}
				} else {
					yyv1421 := &yyv1419[yyj1419]
					yyv1421.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1419 := 0
		for ; !r.CheckBreak(); yyj1419++ {

			if yyj1419 >= len(yyv1419) {
				yyv1419 = append(yyv1419, APIVersion{}) // var yyz1419 APIVersion
				yyc1419 = true
			}
			yyh1419.ElemContainerState(yyj1419)
			if yyj1419 < len(yyv1419) {
				if r.TryDecodeAsNil() {
					yyv1419[yyj1419] = APIVersion{}
				} else {
					yyv1422 := &yyv1419[yyj1419]
					yyv1422.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1419 < len(yyv1419) {
			yyv1419 = yyv1419[:yyj1419]
			yyc1419 = true
		} else if yyj1419 == 0 && yyv1419 == nil {
			yyv1419 = []APIVersion{}
			yyc1419 = true
		}
	}
	yyh1419.End()
	if yyc1419 {
		*v = yyv1419
	}
}

func (x codecSelfer1234) encSliceThirdPartyResource(v []ThirdPartyResource, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1423 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1424 := &yyv1423
		yy1424.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceThirdPartyResource(v *[]ThirdPartyResource, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1425 := *v
	yyh1425, yyl1425 := z.DecSliceHelperStart()
	var yyc1425 bool
	if yyl1425 == 0 {
		if yyv1425 == nil {
			yyv1425 = []ThirdPartyResource{}
			yyc1425 = true
		} else if len(yyv1425) != 0 {
			yyv1425 = yyv1425[:0]
			yyc1425 = true
		}
	} else if yyl1425 > 0 {
		var yyrr1425, yyrl1425 int
		var yyrt1425 bool
		if yyl1425 > cap(yyv1425) {

			yyrg1425 := len(yyv1425) > 0
			yyv21425 := yyv1425
			yyrl1425, yyrt1425 = z.DecInferLen(yyl1425, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1425 {
				if yyrl1425 <= cap(yyv1425) {
					yyv1425 = yyv1425[:yyrl1425]
				} else {
					yyv1425 = make([]ThirdPartyResource, yyrl1425)
				}
			} else {
				yyv1425 = make([]ThirdPartyResource, yyrl1425)
			}
			yyc1425 = true
			yyrr1425 = len(yyv1425)
			if yyrg1425 {
				copy(yyv1425, yyv21425)
			}
		} else if yyl1425 != len(yyv1425) {
			yyv1425 = yyv1425[:yyl1425]
			yyc1425 = true
		}
		yyj1425 := 0
		for ; yyj1425 < yyrr1425; yyj1425++ {
			yyh1425.ElemContainerState(yyj1425)
			if r.TryDecodeAsNil() {
				yyv1425[yyj1425] = ThirdPartyResource{}
			} else {
				yyv1426 := &yyv1425[yyj1425]
				yyv1426.CodecDecodeSelf(d)
			}

		}
		if yyrt1425 {
			for ; yyj1425 < yyl1425; yyj1425++ {
				yyv1425 = append(yyv1425, ThirdPartyResource{})
				yyh1425.ElemContainerState(yyj1425)
				if r.TryDecodeAsNil() {
					yyv1425[yyj1425] = ThirdPartyResource{}
				} else {
					yyv1427 := &yyv1425[yyj1425]
					yyv1427.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1425 := 0
		for ; !r.CheckBreak(); yyj1425++ {

			if yyj1425 >= len(yyv1425) {
				yyv1425 = append(yyv1425, ThirdPartyResource{}) // var yyz1425 ThirdPartyResource
				yyc1425 = true
			}
			yyh1425.ElemContainerState(yyj1425)
			if yyj1425 < len(yyv1425) {
				if r.TryDecodeAsNil() {
					yyv1425[yyj1425] = ThirdPartyResource{}
				} else {
					yyv1428 := &yyv1425[yyj1425]
					yyv1428.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1425 < len(yyv1425) {
			yyv1425 = yyv1425[:yyj1425]
			yyc1425 = true
		} else if yyj1425 == 0 && yyv1425 == nil {
			yyv1425 = []ThirdPartyResource{}
			yyc1425 = true
		}
	}
	yyh1425.End()
	if yyc1425 {
		*v = yyv1425
	}
}

func (x codecSelfer1234) encSliceDeployment(v []Deployment, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1429 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1430 := &yyv1429
		yy1430.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceDeployment(v *[]Deployment, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1431 := *v
	yyh1431, yyl1431 := z.DecSliceHelperStart()
	var yyc1431 bool
	if yyl1431 == 0 {
		if yyv1431 == nil {
			yyv1431 = []Deployment{}
			yyc1431 = true
		} else if len(yyv1431) != 0 {
			yyv1431 = yyv1431[:0]
			yyc1431 = true
		}
	} else if yyl1431 > 0 {
		var yyrr1431, yyrl1431 int
		var yyrt1431 bool
		if yyl1431 > cap(yyv1431) {

			yyrg1431 := len(yyv1431) > 0
			yyv21431 := yyv1431
			yyrl1431, yyrt1431 = z.DecInferLen(yyl1431, z.DecBasicHandle().MaxInitLen, 600)
			if yyrt1431 {
				if yyrl1431 <= cap(yyv1431) {
					yyv1431 = yyv1431[:yyrl1431]
				} else {
					yyv1431 = make([]Deployment, yyrl1431)
				}
			} else {
				yyv1431 = make([]Deployment, yyrl1431)
			}
			yyc1431 = true
			yyrr1431 = len(yyv1431)
			if yyrg1431 {
				copy(yyv1431, yyv21431)
			}
		} else if yyl1431 != len(yyv1431) {
			yyv1431 = yyv1431[:yyl1431]
			yyc1431 = true
		}
		yyj1431 := 0
		for ; yyj1431 < yyrr1431; yyj1431++ {
			yyh1431.ElemContainerState(yyj1431)
			if r.TryDecodeAsNil() {
				yyv1431[yyj1431] = Deployment{}
			} else {
				yyv1432 := &yyv1431[yyj1431]
				yyv1432.CodecDecodeSelf(d)
			}

		}
		if yyrt1431 {
			for ; yyj1431 < yyl1431; yyj1431++ {
				yyv1431 = append(yyv1431, Deployment{})
				yyh1431.ElemContainerState(yyj1431)
				if r.TryDecodeAsNil() {
					yyv1431[yyj1431] = Deployment{}
				} else {
					yyv1433 := &yyv1431[yyj1431]
					yyv1433.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1431 := 0
		for ; !r.CheckBreak(); yyj1431++ {

			if yyj1431 >= len(yyv1431) {
				yyv1431 = append(yyv1431, Deployment{}) // var yyz1431 Deployment
				yyc1431 = true
			}
			yyh1431.ElemContainerState(yyj1431)
			if yyj1431 < len(yyv1431) {
				if r.TryDecodeAsNil() {
					yyv1431[yyj1431] = Deployment{}
				} else {
					yyv1434 := &yyv1431[yyj1431]
					yyv1434.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1431 < len(yyv1431) {
			yyv1431 = yyv1431[:yyj1431]
			yyc1431 = true
		} else if yyj1431 == 0 && yyv1431 == nil {
			yyv1431 = []Deployment{}
			yyc1431 = true
		}
	}
	yyh1431.End()
	if yyc1431 {
		*v = yyv1431
	}
}

func (x codecSelfer1234) encSliceDaemonSet(v []DaemonSet, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1435 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1436 := &yyv1435
		yy1436.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceDaemonSet(v *[]DaemonSet, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1437 := *v
	yyh1437, yyl1437 := z.DecSliceHelperStart()
	var yyc1437 bool
	if yyl1437 == 0 {
		if yyv1437 == nil {
			yyv1437 = []DaemonSet{}
			yyc1437 = true
		} else if len(yyv1437) != 0 {
			yyv1437 = yyv1437[:0]
			yyc1437 = true
		}
	} else if yyl1437 > 0 {
		var yyrr1437, yyrl1437 int
		var yyrt1437 bool
		if yyl1437 > cap(yyv1437) {

			yyrg1437 := len(yyv1437) > 0
			yyv21437 := yyv1437
			yyrl1437, yyrt1437 = z.DecInferLen(yyl1437, z.DecBasicHandle().MaxInitLen, 256)
			if yyrt1437 {
				if yyrl1437 <= cap(yyv1437) {
					yyv1437 = yyv1437[:yyrl1437]
				} else {
					yyv1437 = make([]DaemonSet, yyrl1437)
				}
			} else {
				yyv1437 = make([]DaemonSet, yyrl1437)
			}
			yyc1437 = true
			yyrr1437 = len(yyv1437)
			if yyrg1437 {
				copy(yyv1437, yyv21437)
			}
		} else if yyl1437 != len(yyv1437) {
			yyv1437 = yyv1437[:yyl1437]
			yyc1437 = true
		}
		yyj1437 := 0
		for ; yyj1437 < yyrr1437; yyj1437++ {
			yyh1437.ElemContainerState(yyj1437)
			if r.TryDecodeAsNil() {
				yyv1437[yyj1437] = DaemonSet{}
			} else {
				yyv1438 := &yyv1437[yyj1437]
				yyv1438.CodecDecodeSelf(d)
			}

		}
		if yyrt1437 {
			for ; yyj1437 < yyl1437; yyj1437++ {
				yyv1437 = append(yyv1437, DaemonSet{})
				yyh1437.ElemContainerState(yyj1437)
				if r.TryDecodeAsNil() {
					yyv1437[yyj1437] = DaemonSet{}
				} else {
					yyv1439 := &yyv1437[yyj1437]
					yyv1439.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1437 := 0
		for ; !r.CheckBreak(); yyj1437++ {

			if yyj1437 >= len(yyv1437) {
				yyv1437 = append(yyv1437, DaemonSet{}) // var yyz1437 DaemonSet
				yyc1437 = true
			}
			yyh1437.ElemContainerState(yyj1437)
			if yyj1437 < len(yyv1437) {
				if r.TryDecodeAsNil() {
					yyv1437[yyj1437] = DaemonSet{}
				} else {
					yyv1440 := &yyv1437[yyj1437]
					yyv1440.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1437 < len(yyv1437) {
			yyv1437 = yyv1437[:yyj1437]
			yyc1437 = true
		} else if yyj1437 == 0 && yyv1437 == nil {
			yyv1437 = []DaemonSet{}
			yyc1437 = true
		}
	}
	yyh1437.End()
	if yyc1437 {
		*v = yyv1437
	}
}

func (x codecSelfer1234) encSliceThirdPartyResourceData(v []ThirdPartyResourceData, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1441 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1442 := &yyv1441
		yy1442.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceThirdPartyResourceData(v *[]ThirdPartyResourceData, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1443 := *v
	yyh1443, yyl1443 := z.DecSliceHelperStart()
	var yyc1443 bool
	if yyl1443 == 0 {
		if yyv1443 == nil {
			yyv1443 = []ThirdPartyResourceData{}
			yyc1443 = true
		} else if len(yyv1443) != 0 {
			yyv1443 = yyv1443[:0]
			yyc1443 = true
		}
	} else if yyl1443 > 0 {
		var yyrr1443, yyrl1443 int
		var yyrt1443 bool
		if yyl1443 > cap(yyv1443) {

			yyrg1443 := len(yyv1443) > 0
			yyv21443 := yyv1443
			yyrl1443, yyrt1443 = z.DecInferLen(yyl1443, z.DecBasicHandle().MaxInitLen, 216)
			if yyrt1443 {
				if yyrl1443 <= cap(yyv1443) {
					yyv1443 = yyv1443[:yyrl1443]
				} else {
					yyv1443 = make([]ThirdPartyResourceData, yyrl1443)
				}
			} else {
				yyv1443 = make([]ThirdPartyResourceData, yyrl1443)
			}
			yyc1443 = true
			yyrr1443 = len(yyv1443)
			if yyrg1443 {
				copy(yyv1443, yyv21443)
			}
		} else if yyl1443 != len(yyv1443) {
			yyv1443 = yyv1443[:yyl1443]
			yyc1443 = true
		}
		yyj1443 := 0
		for ; yyj1443 < yyrr1443; yyj1443++ {
			yyh1443.ElemContainerState(yyj1443)
			if r.TryDecodeAsNil() {
				yyv1443[yyj1443] = ThirdPartyResourceData{}
			} else {
				yyv1444 := &yyv1443[yyj1443]
				yyv1444.CodecDecodeSelf(d)
			}

		}
		if yyrt1443 {
			for ; yyj1443 < yyl1443; yyj1443++ {
				yyv1443 = append(yyv1443, ThirdPartyResourceData{})
				yyh1443.ElemContainerState(yyj1443)
				if r.TryDecodeAsNil() {
					yyv1443[yyj1443] = ThirdPartyResourceData{}
				} else {
					yyv1445 := &yyv1443[yyj1443]
					yyv1445.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1443 := 0
		for ; !r.CheckBreak(); yyj1443++ {

			if yyj1443 >= len(yyv1443) {
				yyv1443 = append(yyv1443, ThirdPartyResourceData{}) // var yyz1443 ThirdPartyResourceData
				yyc1443 = true
			}
			yyh1443.ElemContainerState(yyj1443)
			if yyj1443 < len(yyv1443) {
				if r.TryDecodeAsNil() {
					yyv1443[yyj1443] = ThirdPartyResourceData{}
				} else {
					yyv1446 := &yyv1443[yyj1443]
					yyv1446.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1443 < len(yyv1443) {
			yyv1443 = yyv1443[:yyj1443]
			yyc1443 = true
		} else if yyj1443 == 0 && yyv1443 == nil {
			yyv1443 = []ThirdPartyResourceData{}
			yyc1443 = true
		}
	}
	yyh1443.End()
	if yyc1443 {
		*v = yyv1443
	}
}

func (x codecSelfer1234) encSliceJob(v []Job, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1447 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1448 := &yyv1447
		yy1448.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceJob(v *[]Job, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1449 := *v
	yyh1449, yyl1449 := z.DecSliceHelperStart()
	var yyc1449 bool
	if yyl1449 == 0 {
		if yyv1449 == nil {
			yyv1449 = []Job{}
			yyc1449 = true
		} else if len(yyv1449) != 0 {
			yyv1449 = yyv1449[:0]
			yyc1449 = true
		}
	} else if yyl1449 > 0 {
		var yyrr1449, yyrl1449 int
		var yyrt1449 bool
		if yyl1449 > cap(yyv1449) {

			yyrg1449 := len(yyv1449) > 0
			yyv21449 := yyv1449
			yyrl1449, yyrt1449 = z.DecInferLen(yyl1449, z.DecBasicHandle().MaxInitLen, 632)
			if yyrt1449 {
				if yyrl1449 <= cap(yyv1449) {
					yyv1449 = yyv1449[:yyrl1449]
				} else {
					yyv1449 = make([]Job, yyrl1449)
				}
			} else {
				yyv1449 = make([]Job, yyrl1449)
			}
			yyc1449 = true
			yyrr1449 = len(yyv1449)
			if yyrg1449 {
				copy(yyv1449, yyv21449)
			}
		} else if yyl1449 != len(yyv1449) {
			yyv1449 = yyv1449[:yyl1449]
			yyc1449 = true
		}
		yyj1449 := 0
		for ; yyj1449 < yyrr1449; yyj1449++ {
			yyh1449.ElemContainerState(yyj1449)
			if r.TryDecodeAsNil() {
				yyv1449[yyj1449] = Job{}
			} else {
				yyv1450 := &yyv1449[yyj1449]
				yyv1450.CodecDecodeSelf(d)
			}

		}
		if yyrt1449 {
			for ; yyj1449 < yyl1449; yyj1449++ {
				yyv1449 = append(yyv1449, Job{})
				yyh1449.ElemContainerState(yyj1449)
				if r.TryDecodeAsNil() {
					yyv1449[yyj1449] = Job{}
				} else {
					yyv1451 := &yyv1449[yyj1449]
					yyv1451.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1449 := 0
		for ; !r.CheckBreak(); yyj1449++ {

			if yyj1449 >= len(yyv1449) {
				yyv1449 = append(yyv1449, Job{}) // var yyz1449 Job
				yyc1449 = true
			}
			yyh1449.ElemContainerState(yyj1449)
			if yyj1449 < len(yyv1449) {
				if r.TryDecodeAsNil() {
					yyv1449[yyj1449] = Job{}
				} else {
					yyv1452 := &yyv1449[yyj1449]
					yyv1452.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1449 < len(yyv1449) {
			yyv1449 = yyv1449[:yyj1449]
			yyc1449 = true
		} else if yyj1449 == 0 && yyv1449 == nil {
			yyv1449 = []Job{}
			yyc1449 = true
		}
	}
	yyh1449.End()
	if yyc1449 {
		*v = yyv1449
	}
}

func (x codecSelfer1234) encSliceJobCondition(v []JobCondition, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1453 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1454 := &yyv1453
		yy1454.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceJobCondition(v *[]JobCondition, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1455 := *v
	yyh1455, yyl1455 := z.DecSliceHelperStart()
	var yyc1455 bool
	if yyl1455 == 0 {
		if yyv1455 == nil {
			yyv1455 = []JobCondition{}
			yyc1455 = true
		} else if len(yyv1455) != 0 {
			yyv1455 = yyv1455[:0]
			yyc1455 = true
		}
	} else if yyl1455 > 0 {
		var yyrr1455, yyrl1455 int
		var yyrt1455 bool
		if yyl1455 > cap(yyv1455) {

			yyrg1455 := len(yyv1455) > 0
			yyv21455 := yyv1455
			yyrl1455, yyrt1455 = z.DecInferLen(yyl1455, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1455 {
				if yyrl1455 <= cap(yyv1455) {
					yyv1455 = yyv1455[:yyrl1455]
				} else {
					yyv1455 = make([]JobCondition, yyrl1455)
				}
			} else {
				yyv1455 = make([]JobCondition, yyrl1455)
			}
			yyc1455 = true
			yyrr1455 = len(yyv1455)
			if yyrg1455 {
				copy(yyv1455, yyv21455)
			}
		} else if yyl1455 != len(yyv1455) {
			yyv1455 = yyv1455[:yyl1455]
			yyc1455 = true
		}
		yyj1455 := 0
		for ; yyj1455 < yyrr1455; yyj1455++ {
			yyh1455.ElemContainerState(yyj1455)
			if r.TryDecodeAsNil() {
				yyv1455[yyj1455] = JobCondition{}
			} else {
				yyv1456 := &yyv1455[yyj1455]
				yyv1456.CodecDecodeSelf(d)
			}

		}
		if yyrt1455 {
			for ; yyj1455 < yyl1455; yyj1455++ {
				yyv1455 = append(yyv1455, JobCondition{})
				yyh1455.ElemContainerState(yyj1455)
				if r.TryDecodeAsNil() {
					yyv1455[yyj1455] = JobCondition{}
				} else {
					yyv1457 := &yyv1455[yyj1455]
					yyv1457.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1455 := 0
		for ; !r.CheckBreak(); yyj1455++ {

			if yyj1455 >= len(yyv1455) {
				yyv1455 = append(yyv1455, JobCondition{}) // var yyz1455 JobCondition
				yyc1455 = true
			}
			yyh1455.ElemContainerState(yyj1455)
			if yyj1455 < len(yyv1455) {
				if r.TryDecodeAsNil() {
					yyv1455[yyj1455] = JobCondition{}
				} else {
					yyv1458 := &yyv1455[yyj1455]
					yyv1458.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1455 < len(yyv1455) {
			yyv1455 = yyv1455[:yyj1455]
			yyc1455 = true
		} else if yyj1455 == 0 && yyv1455 == nil {
			yyv1455 = []JobCondition{}
			yyc1455 = true
		}
	}
	yyh1455.End()
	if yyc1455 {
		*v = yyv1455
	}
}

func (x codecSelfer1234) encSliceIngress(v []Ingress, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1459 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1460 := &yyv1459
		yy1460.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIngress(v *[]Ingress, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1461 := *v
	yyh1461, yyl1461 := z.DecSliceHelperStart()
	var yyc1461 bool
	if yyl1461 == 0 {
		if yyv1461 == nil {
			yyv1461 = []Ingress{}
			yyc1461 = true
		} else if len(yyv1461) != 0 {
			yyv1461 = yyv1461[:0]
			yyc1461 = true
		}
	} else if yyl1461 > 0 {
		var yyrr1461, yyrl1461 int
		var yyrt1461 bool
		if yyl1461 > cap(yyv1461) {

			yyrg1461 := len(yyv1461) > 0
			yyv21461 := yyv1461
			yyrl1461, yyrt1461 = z.DecInferLen(yyl1461, z.DecBasicHandle().MaxInitLen, 248)
			if yyrt1461 {
				if yyrl1461 <= cap(yyv1461) {
					yyv1461 = yyv1461[:yyrl1461]
				} else {
					yyv1461 = make([]Ingress, yyrl1461)
				}
			} else {
				yyv1461 = make([]Ingress, yyrl1461)
			}
			yyc1461 = true
			yyrr1461 = len(yyv1461)
			if yyrg1461 {
				copy(yyv1461, yyv21461)
			}
		} else if yyl1461 != len(yyv1461) {
			yyv1461 = yyv1461[:yyl1461]
			yyc1461 = true
		}
		yyj1461 := 0
		for ; yyj1461 < yyrr1461; yyj1461++ {
			yyh1461.ElemContainerState(yyj1461)
			if r.TryDecodeAsNil() {
				yyv1461[yyj1461] = Ingress{}
			} else {
				yyv1462 := &yyv1461[yyj1461]
				yyv1462.CodecDecodeSelf(d)
			}

		}
		if yyrt1461 {
			for ; yyj1461 < yyl1461; yyj1461++ {
				yyv1461 = append(yyv1461, Ingress{})
				yyh1461.ElemContainerState(yyj1461)
				if r.TryDecodeAsNil() {
					yyv1461[yyj1461] = Ingress{}
				} else {
					yyv1463 := &yyv1461[yyj1461]
					yyv1463.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1461 := 0
		for ; !r.CheckBreak(); yyj1461++ {

			if yyj1461 >= len(yyv1461) {
				yyv1461 = append(yyv1461, Ingress{}) // var yyz1461 Ingress
				yyc1461 = true
			}
			yyh1461.ElemContainerState(yyj1461)
			if yyj1461 < len(yyv1461) {
				if r.TryDecodeAsNil() {
					yyv1461[yyj1461] = Ingress{}
				} else {
					yyv1464 := &yyv1461[yyj1461]
					yyv1464.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1461 < len(yyv1461) {
			yyv1461 = yyv1461[:yyj1461]
			yyc1461 = true
		} else if yyj1461 == 0 && yyv1461 == nil {
			yyv1461 = []Ingress{}
			yyc1461 = true
		}
	}
	yyh1461.End()
	if yyc1461 {
		*v = yyv1461
	}
}

func (x codecSelfer1234) encSliceIngressRule(v []IngressRule, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1465 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1466 := &yyv1465
		yy1466.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceIngressRule(v *[]IngressRule, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1467 := *v
	yyh1467, yyl1467 := z.DecSliceHelperStart()
	var yyc1467 bool
	if yyl1467 == 0 {
		if yyv1467 == nil {
			yyv1467 = []IngressRule{}
			yyc1467 = true
		} else if len(yyv1467) != 0 {
			yyv1467 = yyv1467[:0]
			yyc1467 = true
		}
	} else if yyl1467 > 0 {
		var yyrr1467, yyrl1467 int
		var yyrt1467 bool
		if yyl1467 > cap(yyv1467) {

			yyrg1467 := len(yyv1467) > 0
			yyv21467 := yyv1467
			yyrl1467, yyrt1467 = z.DecInferLen(yyl1467, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1467 {
				if yyrl1467 <= cap(yyv1467) {
					yyv1467 = yyv1467[:yyrl1467]
				} else {
					yyv1467 = make([]IngressRule, yyrl1467)
				}
			} else {
				yyv1467 = make([]IngressRule, yyrl1467)
			}
			yyc1467 = true
			yyrr1467 = len(yyv1467)
			if yyrg1467 {
				copy(yyv1467, yyv21467)
			}
		} else if yyl1467 != len(yyv1467) {
			yyv1467 = yyv1467[:yyl1467]
			yyc1467 = true
		}
		yyj1467 := 0
		for ; yyj1467 < yyrr1467; yyj1467++ {
			yyh1467.ElemContainerState(yyj1467)
			if r.TryDecodeAsNil() {
				yyv1467[yyj1467] = IngressRule{}
			} else {
				yyv1468 := &yyv1467[yyj1467]
				yyv1468.CodecDecodeSelf(d)
			}

		}
		if yyrt1467 {
			for ; yyj1467 < yyl1467; yyj1467++ {
				yyv1467 = append(yyv1467, IngressRule{})
				yyh1467.ElemContainerState(yyj1467)
				if r.TryDecodeAsNil() {
					yyv1467[yyj1467] = IngressRule{}
				} else {
					yyv1469 := &yyv1467[yyj1467]
					yyv1469.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1467 := 0
		for ; !r.CheckBreak(); yyj1467++ {

			if yyj1467 >= len(yyv1467) {
				yyv1467 = append(yyv1467, IngressRule{}) // var yyz1467 IngressRule
				yyc1467 = true
			}
			yyh1467.ElemContainerState(yyj1467)
			if yyj1467 < len(yyv1467) {
				if r.TryDecodeAsNil() {
					yyv1467[yyj1467] = IngressRule{}
				} else {
					yyv1470 := &yyv1467[yyj1467]
					yyv1470.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1467 < len(yyv1467) {
			yyv1467 = yyv1467[:yyj1467]
			yyc1467 = true
		} else if yyj1467 == 0 && yyv1467 == nil {
			yyv1467 = []IngressRule{}
			yyc1467 = true
		}
	}
	yyh1467.End()
	if yyc1467 {
		*v = yyv1467
	}
}

func (x codecSelfer1234) encSliceHTTPIngressPath(v []HTTPIngressPath, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1471 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1472 := &yyv1471
		yy1472.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceHTTPIngressPath(v *[]HTTPIngressPath, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1473 := *v
	yyh1473, yyl1473 := z.DecSliceHelperStart()
	var yyc1473 bool
	if yyl1473 == 0 {
		if yyv1473 == nil {
			yyv1473 = []HTTPIngressPath{}
			yyc1473 = true
		} else if len(yyv1473) != 0 {
			yyv1473 = yyv1473[:0]
			yyc1473 = true
		}
	} else if yyl1473 > 0 {
		var yyrr1473, yyrl1473 int
		var yyrt1473 bool
		if yyl1473 > cap(yyv1473) {

			yyrg1473 := len(yyv1473) > 0
			yyv21473 := yyv1473
			yyrl1473, yyrt1473 = z.DecInferLen(yyl1473, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1473 {
				if yyrl1473 <= cap(yyv1473) {
					yyv1473 = yyv1473[:yyrl1473]
				} else {
					yyv1473 = make([]HTTPIngressPath, yyrl1473)
				}
			} else {
				yyv1473 = make([]HTTPIngressPath, yyrl1473)
			}
			yyc1473 = true
			yyrr1473 = len(yyv1473)
			if yyrg1473 {
				copy(yyv1473, yyv21473)
			}
		} else if yyl1473 != len(yyv1473) {
			yyv1473 = yyv1473[:yyl1473]
			yyc1473 = true
		}
		yyj1473 := 0
		for ; yyj1473 < yyrr1473; yyj1473++ {
			yyh1473.ElemContainerState(yyj1473)
			if r.TryDecodeAsNil() {
				yyv1473[yyj1473] = HTTPIngressPath{}
			} else {
				yyv1474 := &yyv1473[yyj1473]
				yyv1474.CodecDecodeSelf(d)
			}

		}
		if yyrt1473 {
			for ; yyj1473 < yyl1473; yyj1473++ {
				yyv1473 = append(yyv1473, HTTPIngressPath{})
				yyh1473.ElemContainerState(yyj1473)
				if r.TryDecodeAsNil() {
					yyv1473[yyj1473] = HTTPIngressPath{}
				} else {
					yyv1475 := &yyv1473[yyj1473]
					yyv1475.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1473 := 0
		for ; !r.CheckBreak(); yyj1473++ {

			if yyj1473 >= len(yyv1473) {
				yyv1473 = append(yyv1473, HTTPIngressPath{}) // var yyz1473 HTTPIngressPath
				yyc1473 = true
			}
			yyh1473.ElemContainerState(yyj1473)
			if yyj1473 < len(yyv1473) {
				if r.TryDecodeAsNil() {
					yyv1473[yyj1473] = HTTPIngressPath{}
				} else {
					yyv1476 := &yyv1473[yyj1473]
					yyv1476.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1473 < len(yyv1473) {
			yyv1473 = yyv1473[:yyj1473]
			yyc1473 = true
		} else if yyj1473 == 0 && yyv1473 == nil {
			yyv1473 = []HTTPIngressPath{}
			yyc1473 = true
		}
	}
	yyh1473.End()
	if yyc1473 {
		*v = yyv1473
	}
}

func (x codecSelfer1234) encSliceNodeUtilization(v []NodeUtilization, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1477 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1478 := &yyv1477
		yy1478.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceNodeUtilization(v *[]NodeUtilization, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1479 := *v
	yyh1479, yyl1479 := z.DecSliceHelperStart()
	var yyc1479 bool
	if yyl1479 == 0 {
		if yyv1479 == nil {
			yyv1479 = []NodeUtilization{}
			yyc1479 = true
		} else if len(yyv1479) != 0 {
			yyv1479 = yyv1479[:0]
			yyc1479 = true
		}
	} else if yyl1479 > 0 {
		var yyrr1479, yyrl1479 int
		var yyrt1479 bool
		if yyl1479 > cap(yyv1479) {

			yyrg1479 := len(yyv1479) > 0
			yyv21479 := yyv1479
			yyrl1479, yyrt1479 = z.DecInferLen(yyl1479, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1479 {
				if yyrl1479 <= cap(yyv1479) {
					yyv1479 = yyv1479[:yyrl1479]
				} else {
					yyv1479 = make([]NodeUtilization, yyrl1479)
				}
			} else {
				yyv1479 = make([]NodeUtilization, yyrl1479)
			}
			yyc1479 = true
			yyrr1479 = len(yyv1479)
			if yyrg1479 {
				copy(yyv1479, yyv21479)
			}
		} else if yyl1479 != len(yyv1479) {
			yyv1479 = yyv1479[:yyl1479]
			yyc1479 = true
		}
		yyj1479 := 0
		for ; yyj1479 < yyrr1479; yyj1479++ {
			yyh1479.ElemContainerState(yyj1479)
			if r.TryDecodeAsNil() {
				yyv1479[yyj1479] = NodeUtilization{}
			} else {
				yyv1480 := &yyv1479[yyj1479]
				yyv1480.CodecDecodeSelf(d)
			}

		}
		if yyrt1479 {
			for ; yyj1479 < yyl1479; yyj1479++ {
				yyv1479 = append(yyv1479, NodeUtilization{})
				yyh1479.ElemContainerState(yyj1479)
				if r.TryDecodeAsNil() {
					yyv1479[yyj1479] = NodeUtilization{}
				} else {
					yyv1481 := &yyv1479[yyj1479]
					yyv1481.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1479 := 0
		for ; !r.CheckBreak(); yyj1479++ {

			if yyj1479 >= len(yyv1479) {
				yyv1479 = append(yyv1479, NodeUtilization{}) // var yyz1479 NodeUtilization
				yyc1479 = true
			}
			yyh1479.ElemContainerState(yyj1479)
			if yyj1479 < len(yyv1479) {
				if r.TryDecodeAsNil() {
					yyv1479[yyj1479] = NodeUtilization{}
				} else {
					yyv1482 := &yyv1479[yyj1479]
					yyv1482.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1479 < len(yyv1479) {
			yyv1479 = yyv1479[:yyj1479]
			yyc1479 = true
		} else if yyj1479 == 0 && yyv1479 == nil {
			yyv1479 = []NodeUtilization{}
			yyc1479 = true
		}
	}
	yyh1479.End()
	if yyc1479 {
		*v = yyv1479
	}
}

func (x codecSelfer1234) encSliceClusterAutoscaler(v []ClusterAutoscaler, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1483 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1484 := &yyv1483
		yy1484.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceClusterAutoscaler(v *[]ClusterAutoscaler, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1485 := *v
	yyh1485, yyl1485 := z.DecSliceHelperStart()
	var yyc1485 bool
	if yyl1485 == 0 {
		if yyv1485 == nil {
			yyv1485 = []ClusterAutoscaler{}
			yyc1485 = true
		} else if len(yyv1485) != 0 {
			yyv1485 = yyv1485[:0]
			yyc1485 = true
		}
	} else if yyl1485 > 0 {
		var yyrr1485, yyrl1485 int
		var yyrt1485 bool
		if yyl1485 > cap(yyv1485) {

			yyrg1485 := len(yyv1485) > 0
			yyv21485 := yyv1485
			yyrl1485, yyrt1485 = z.DecInferLen(yyl1485, z.DecBasicHandle().MaxInitLen, 224)
			if yyrt1485 {
				if yyrl1485 <= cap(yyv1485) {
					yyv1485 = yyv1485[:yyrl1485]
				} else {
					yyv1485 = make([]ClusterAutoscaler, yyrl1485)
				}
			} else {
				yyv1485 = make([]ClusterAutoscaler, yyrl1485)
			}
			yyc1485 = true
			yyrr1485 = len(yyv1485)
			if yyrg1485 {
				copy(yyv1485, yyv21485)
			}
		} else if yyl1485 != len(yyv1485) {
			yyv1485 = yyv1485[:yyl1485]
			yyc1485 = true
		}
		yyj1485 := 0
		for ; yyj1485 < yyrr1485; yyj1485++ {
			yyh1485.ElemContainerState(yyj1485)
			if r.TryDecodeAsNil() {
				yyv1485[yyj1485] = ClusterAutoscaler{}
			} else {
				yyv1486 := &yyv1485[yyj1485]
				yyv1486.CodecDecodeSelf(d)
			}

		}
		if yyrt1485 {
			for ; yyj1485 < yyl1485; yyj1485++ {
				yyv1485 = append(yyv1485, ClusterAutoscaler{})
				yyh1485.ElemContainerState(yyj1485)
				if r.TryDecodeAsNil() {
					yyv1485[yyj1485] = ClusterAutoscaler{}
				} else {
					yyv1487 := &yyv1485[yyj1485]
					yyv1487.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1485 := 0
		for ; !r.CheckBreak(); yyj1485++ {

			if yyj1485 >= len(yyv1485) {
				yyv1485 = append(yyv1485, ClusterAutoscaler{}) // var yyz1485 ClusterAutoscaler
				yyc1485 = true
			}
			yyh1485.ElemContainerState(yyj1485)
			if yyj1485 < len(yyv1485) {
				if r.TryDecodeAsNil() {
					yyv1485[yyj1485] = ClusterAutoscaler{}
				} else {
					yyv1488 := &yyv1485[yyj1485]
					yyv1488.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1485 < len(yyv1485) {
			yyv1485 = yyv1485[:yyj1485]
			yyc1485 = true
		} else if yyj1485 == 0 && yyv1485 == nil {
			yyv1485 = []ClusterAutoscaler{}
			yyc1485 = true
		}
	}
	yyh1485.End()
	if yyc1485 {
		*v = yyv1485
	}
}

func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequirement, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1489 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1490 := &yyv1489
		yy1490.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceLabelSelectorRequirement(v *[]LabelSelectorRequirement, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1491 := *v
	yyh1491, yyl1491 := z.DecSliceHelperStart()
	var yyc1491 bool
	if yyl1491 == 0 {
		if yyv1491 == nil {
			yyv1491 = []LabelSelectorRequirement{}
			yyc1491 = true
		} else if len(yyv1491) != 0 {
			yyv1491 = yyv1491[:0]
			yyc1491 = true
		}
	} else if yyl1491 > 0 {
		var yyrr1491, yyrl1491 int
		var yyrt1491 bool
		if yyl1491 > cap(yyv1491) {

			yyrg1491 := len(yyv1491) > 0
			yyv21491 := yyv1491
			yyrl1491, yyrt1491 = z.DecInferLen(yyl1491, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt1491 {
				if yyrl1491 <= cap(yyv1491) {
					yyv1491 = yyv1491[:yyrl1491]
				} else {
					yyv1491 = make([]LabelSelectorRequirement, yyrl1491)
				}
			} else {
				yyv1491 = make([]LabelSelectorRequirement, yyrl1491)
			}
			yyc1491 = true
			yyrr1491 = len(yyv1491)
			if yyrg1491 {
				copy(yyv1491, yyv21491)
			}
		} else if yyl1491 != len(yyv1491) {
			yyv1491 = yyv1491[:yyl1491]
			yyc1491 = true
		}
		yyj1491 := 0
		for ; yyj1491 < yyrr1491; yyj1491++ {
			yyh1491.ElemContainerState(yyj1491)
			if r.TryDecodeAsNil() {
				yyv1491[yyj1491] = LabelSelectorRequirement{}
			} else {
				yyv1492 := &yyv1491[yyj1491]
				yyv1492.CodecDecodeSelf(d)
			}

		}
		if yyrt1491 {
			for ; yyj1491 < yyl1491; yyj1491++ {
				yyv1491 = append(yyv1491, LabelSelectorRequirement{})
				yyh1491.ElemContainerState(yyj1491)
				if r.TryDecodeAsNil() {
					yyv1491[yyj1491] = LabelSelectorRequirement{}
				} else {
					yyv1493 := &yyv1491[yyj1491]
					yyv1493.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1491 := 0
		for ; !r.CheckBreak(); yyj1491++ {

			if yyj1491 >= len(yyv1491) {
				yyv1491 = append(yyv1491, LabelSelectorRequirement{}) // var yyz1491 LabelSelectorRequirement
				yyc1491 = true
			}
			yyh1491.ElemContainerState(yyj1491)
			if yyj1491 < len(yyv1491) {
				if r.TryDecodeAsNil() {
					yyv1491[yyj1491] = LabelSelectorRequirement{}
				} else {
					yyv1494 := &yyv1491[yyj1491]
					yyv1494.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1491 < len(yyv1491) {
			yyv1491 = yyv1491[:yyj1491]
			yyc1491 = true
		} else if yyj1491 == 0 && yyv1491 == nil {
			yyv1491 = []LabelSelectorRequirement{}
			yyc1491 = true
		}
	}
	yyh1491.End()
	if yyc1491 {
		*v = yyv1491
	}
}

func (x codecSelfer1234) encSliceConfigMap(v []ConfigMap, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1495 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1496 := &yyv1495
		yy1496.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1497 := *v
	yyh1497, yyl1497 := z.DecSliceHelperStart()
	var yyc1497 bool
	if yyl1497 == 0 {
		if yyv1497 == nil {
			yyv1497 = []ConfigMap{}
			yyc1497 = true
		} else if len(yyv1497) != 0 {
			yyv1497 = yyv1497[:0]
			yyc1497 = true
		}
	} else if yyl1497 > 0 {
		var yyrr1497, yyrl1497 int
		var yyrt1497 bool
		if yyl1497 > cap(yyv1497) {

			yyrg1497 := len(yyv1497) > 0
			yyv21497 := yyv1497
			yyrl1497, yyrt1497 = z.DecInferLen(yyl1497, z.DecBasicHandle().MaxInitLen, 200)
			if yyrt1497 {
				if yyrl1497 <= cap(yyv1497) {
					yyv1497 = yyv1497[:yyrl1497]
				} else {
					yyv1497 = make([]ConfigMap, yyrl1497)
				}
			} else {
				yyv1497 = make([]ConfigMap, yyrl1497)
			}
			yyc1497 = true
			yyrr1497 = len(yyv1497)
			if yyrg1497 {
				copy(yyv1497, yyv21497)
			}
		} else if yyl1497 != len(yyv1497) {
			yyv1497 = yyv1497[:yyl1497]
			yyc1497 = true
		}
		yyj1497 := 0
		for ; yyj1497 < yyrr1497; yyj1497++ {
			yyh1497.ElemContainerState(yyj1497)
			if r.TryDecodeAsNil() {
				yyv1497[yyj1497] = ConfigMap{}
			} else {
				yyv1498 := &yyv1497[yyj1497]
				yyv1498.CodecDecodeSelf(d)
			}

		}
		if yyrt1497 {
			for ; yyj1497 < yyl1497; yyj1497++ {
				yyv1497 = append(yyv1497, ConfigMap{})
				yyh1497.ElemContainerState(yyj1497)
				if r.TryDecodeAsNil() {
					yyv1497[yyj1497] = ConfigMap{}
				} else {
					yyv1499 := &yyv1497[yyj1497]
					yyv1499.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1497 := 0
		for ; !r.CheckBreak(); yyj1497++ {

			if yyj1497 >= len(yyv1497) {
				yyv1497 = append(yyv1497, ConfigMap{}) // var yyz1497 ConfigMap
				yyc1497 = true
			}
			yyh1497.ElemContainerState(yyj1497)
			if yyj1497 < len(yyv1497) {
				if r.TryDecodeAsNil() {
					yyv1497[yyj1497] = ConfigMap{}
				} else {
					yyv1500 := &yyv1497[yyj1497]
					yyv1500.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1497 < len(yyv1497) {
			yyv1497 = yyv1497[:yyj1497]
			yyc1497 = true
		} else if yyj1497 == 0 && yyv1497 == nil {
			yyv1497 = []ConfigMap{}
			yyc1497 = true
		}
	}
	yyh1497.End()
	if yyc1497 {
		*v = yyv1497
	}
}

func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1501 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1502 := &yyv1501
		yy1502.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) decSliceReplicaSet(v *[]ReplicaSet, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1503 := *v
	yyh1503, yyl1503 := z.DecSliceHelperStart()
	var yyc1503 bool
	if yyl1503 == 0 {
		if yyv1503 == nil {
			yyv1503 = []ReplicaSet{}
			yyc1503 = true
		} else if len(yyv1503) != 0 {
			yyv1503 = yyv1503[:0]
			yyc1503 = true
		}
	} else if yyl1503 > 0 {
		var yyrr1503, yyrl1503 int
		var yyrt1503 bool
		if yyl1503 > cap(yyv1503) {

			yyrg1503 := len(yyv1503) > 0
			yyv21503 := yyv1503
			yyrl1503, yyrt1503 = z.DecInferLen(yyl1503, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1503 {
				if yyrl1503 <= cap(yyv1503) {
					yyv1503 = yyv1503[:yyrl1503]
				} else {
					yyv1503 = make([]ReplicaSet, yyrl1503)
				}
			} else {
				yyv1503 = make([]ReplicaSet, yyrl1503)
			}
			yyc1503 = true
			yyrr1503 = len(yyv1503)
			if yyrg1503 {
				copy(yyv1503, yyv21503)
			}
		} else if yyl1503 != len(yyv1503) {
			yyv1503 = yyv1503[:yyl1503]
			yyc1503 = true
		}
		yyj1503 := 0
		for ; yyj1503 < yyrr1503; yyj1503++ {
			yyh1503.ElemContainerState(yyj1503)
			if r.TryDecodeAsNil() {
				yyv1503[yyj1503] = ReplicaSet{}
			} else {
				yyv1504 := &yyv1503[yyj1503]
				yyv1504.CodecDecodeSelf(d)
			}

		}
		if yyrt1503 {
			for ; yyj1503 < yyl1503; yyj1503++ {
				yyv1503 = append(yyv1503, ReplicaSet{})
				yyh1503.ElemContainerState(yyj1503)
				if r.TryDecodeAsNil() {
					yyv1503[yyj1503] = ReplicaSet{}
				} else {
					yyv1505 := &yyv1503[yyj1503]
					yyv1505.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1503 := 0
		for ; !r.CheckBreak(); yyj1503++ {

			if yyj1503 >= len(yyv1503) {
				yyv1503 = append(yyv1503, ReplicaSet{}) // var yyz1503 ReplicaSet
				yyc1503 = true
			}
			yyh1503.ElemContainerState(yyj1503)
			if yyj1503 < len(yyv1503) {
				if r.TryDecodeAsNil() {
					yyv1503[yyj1503] = ReplicaSet{}
				} else {
					yyv1506 := &yyv1503[yyj1503]
					yyv1506.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1503 < len(yyv1503) {
			yyv1503 = yyv1503[:yyj1503]
			yyc1503 = true
		} else if yyj1503 == 0 && yyv1503 == nil {
			yyv1503 = []ReplicaSet{}
			yyc1503 = true
		}
	}
	yyh1503.End()
	if yyc1503 {
		*v = yyv1503
	}
}
