/*
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 extensions

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg2_api "k8s.io/kubernetes/pkg/api"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	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 pkg2_api.ObjectMeta
		var v1 pkg4_resource.Quantity
		var v2 pkg1_unversioned.TypeMeta
		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 = int(r.DecodeInt(codecSelferBitsize1234))
			}
		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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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 = int(r.DecodeInt(codecSelferBitsize1234))
			}
		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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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_api.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_api.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 = int(r.DecodeInt(codecSelferBitsize1234))
			}
		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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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(int)
				}
				yym133 := z.DecBinary()
				_ = yym133
				if false {
				} else {
					*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		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(int)
		}
		yym139 := z.DecBinary()
		_ = yym139
		if false {
		} else {
			*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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 = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int)
				}
				yym173 := z.DecBinary()
				_ = yym173
				if false {
				} else {
					*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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 = int(r.DecodeInt(codecSelferBitsize1234))
	}
	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(int)
		}
		yym182 := z.DecBinary()
		_ = yym182
		if false {
		} else {
			*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	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_api.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_api.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_api.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_api.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_api.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_api.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_api.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_api.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 != 0
			yyq387[1] = len(x.Selector) != 0
			yyq387[3] = true
			yyq387[4] = x.UniqueLabelKey != ""
			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] {
					yym389 := z.EncBinary()
					_ = yym389
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq387[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym390 := z.EncBinary()
					_ = yym390
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym392 := z.EncBinary()
						_ = yym392
						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 {
						yym393 := z.EncBinary()
						_ = yym393
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy395 := &x.Template
				yy395.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy396 := &x.Template
				yy396.CodecEncodeSelf(e)
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[3] {
					yy398 := &x.Strategy
					yy398.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy399 := &x.Strategy
					yy399.CodecEncodeSelf(e)
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[4] {
					yym401 := z.EncBinary()
					_ = yym401
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq387[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym402 := z.EncBinary()
					_ = yym402
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				}
			}
			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
	yym403 := z.DecBinary()
	_ = yym403
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct404 := r.ContainerType()
		if yyct404 == codecSelferValueTypeMap1234 {
			yyl404 := r.ReadMapStart()
			if yyl404 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl404, d)
			}
		} else if yyct404 == codecSelferValueTypeArray1234 {
			yyl404 := r.ReadArrayStart()
			if yyl404 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl404, 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 yys405Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys405Slc
	var yyhl405 bool = l >= 0
	for yyj405 := 0; ; yyj405++ {
		if yyhl405 {
			if yyj405 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys405Slc = r.DecodeBytes(yys405Slc, true, true)
		yys405 := string(yys405Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys405 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv407 := &x.Selector
				yym408 := z.DecBinary()
				_ = yym408
				if false {
				} else {
					z.F.DecMapStringStringX(yyv407, false, d)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv409 := &x.Template
				yyv409.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv410 := &x.Strategy
				yyv410.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				x.UniqueLabelKey = ""
			} else {
				x.UniqueLabelKey = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys405)
		} // end switch yys405
	} // end for yyj405
	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 yyj412 int
	var yyb412 bool
	var yyhl412 bool = l >= 0
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv414 := &x.Selector
		yym415 := z.DecBinary()
		_ = yym415
		if false {
		} else {
			z.F.DecMapStringStringX(yyv414, false, d)
		}
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv416 := &x.Template
		yyv416.CodecDecodeSelf(d)
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv417 := &x.Strategy
		yyv417.CodecDecodeSelf(d)
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UniqueLabelKey = ""
	} else {
		x.UniqueLabelKey = string(r.DecodeString())
	}
	for {
		yyj412++
		if yyhl412 {
			yyb412 = yyj412 > l
		} else {
			yyb412 = r.CheckBreak()
		}
		if yyb412 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj412-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 {
		yym419 := z.EncBinary()
		_ = yym419
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep420 := !z.EncBinary()
			yy2arr420 := z.EncBasicHandle().StructToArray
			var yyq420 [2]bool
			_, _, _ = yysep420, yyq420, yy2arr420
			const yyr420 bool = false
			yyq420[0] = x.Type != ""
			yyq420[1] = x.RollingUpdate != nil
			var yynn420 int
			if yyr420 || yy2arr420 {
				r.EncodeArrayStart(2)
			} else {
				yynn420 = 0
				for _, b := range yyq420 {
					if b {
						yynn420++
					}
				}
				r.EncodeMapStart(yynn420)
				yynn420 = 0
			}
			if yyr420 || yy2arr420 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq420[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq420[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr420 || yy2arr420 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq420[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq420[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 yyr420 || yy2arr420 {
				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
	yym423 := z.DecBinary()
	_ = yym423
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct424 := r.ContainerType()
		if yyct424 == codecSelferValueTypeMap1234 {
			yyl424 := r.ReadMapStart()
			if yyl424 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl424, d)
			}
		} else if yyct424 == codecSelferValueTypeArray1234 {
			yyl424 := r.ReadArrayStart()
			if yyl424 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl424, 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 yys425Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys425Slc
	var yyhl425 bool = l >= 0
	for yyj425 := 0; ; yyj425++ {
		if yyhl425 {
			if yyj425 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys425Slc = r.DecodeBytes(yys425Slc, true, true)
		yys425 := string(yys425Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys425 {
		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, yys425)
		} // end switch yys425
	} // end for yyj425
	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 yyj428 int
	var yyb428 bool
	var yyhl428 bool = l >= 0
	yyj428++
	if yyhl428 {
		yyb428 = yyj428 > l
	} else {
		yyb428 = r.CheckBreak()
	}
	if yyb428 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj428++
	if yyhl428 {
		yyb428 = yyj428 > l
	} else {
		yyb428 = r.CheckBreak()
	}
	if yyb428 {
		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 {
		yyj428++
		if yyhl428 {
			yyb428 = yyj428 > l
		} else {
			yyb428 = r.CheckBreak()
		}
		if yyb428 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj428-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym431 := z.EncBinary()
	_ = yym431
	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
	yym432 := z.DecBinary()
	_ = yym432
	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 {
		yym433 := z.EncBinary()
		_ = yym433
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep434 := !z.EncBinary()
			yy2arr434 := z.EncBasicHandle().StructToArray
			var yyq434 [3]bool
			_, _, _ = yysep434, yyq434, yy2arr434
			const yyr434 bool = false
			yyq434[0] = true
			yyq434[1] = true
			yyq434[2] = x.MinReadySeconds != 0
			var yynn434 int
			if yyr434 || yy2arr434 {
				r.EncodeArrayStart(3)
			} else {
				yynn434 = 0
				for _, b := range yyq434 {
					if b {
						yynn434++
					}
				}
				r.EncodeMapStart(yynn434)
				yynn434 = 0
			}
			if yyr434 || yy2arr434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq434[0] {
					yy436 := &x.MaxUnavailable
					yym437 := z.EncBinary()
					_ = yym437
					if false {
					} else if z.HasExtensions() && z.EncExt(yy436) {
					} else if !yym437 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy436)
					} else {
						z.EncFallback(yy436)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq434[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy438 := &x.MaxUnavailable
					yym439 := z.EncBinary()
					_ = yym439
					if false {
					} else if z.HasExtensions() && z.EncExt(yy438) {
					} else if !yym439 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy438)
					} else {
						z.EncFallback(yy438)
					}
				}
			}
			if yyr434 || yy2arr434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq434[1] {
					yy441 := &x.MaxSurge
					yym442 := z.EncBinary()
					_ = yym442
					if false {
					} else if z.HasExtensions() && z.EncExt(yy441) {
					} else if !yym442 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy441)
					} else {
						z.EncFallback(yy441)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq434[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy443 := &x.MaxSurge
					yym444 := z.EncBinary()
					_ = yym444
					if false {
					} else if z.HasExtensions() && z.EncExt(yy443) {
					} else if !yym444 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy443)
					} else {
						z.EncFallback(yy443)
					}
				}
			}
			if yyr434 || yy2arr434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq434[2] {
					yym446 := z.EncBinary()
					_ = yym446
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq434[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym447 := z.EncBinary()
					_ = yym447
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr434 || yy2arr434 {
				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
	yym448 := z.DecBinary()
	_ = yym448
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct449 := r.ContainerType()
		if yyct449 == codecSelferValueTypeMap1234 {
			yyl449 := r.ReadMapStart()
			if yyl449 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl449, d)
			}
		} else if yyct449 == codecSelferValueTypeArray1234 {
			yyl449 := r.ReadArrayStart()
			if yyl449 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl449, 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 yys450Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys450Slc
	var yyhl450 bool = l >= 0
	for yyj450 := 0; ; yyj450++ {
		if yyhl450 {
			if yyj450 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys450Slc = r.DecodeBytes(yys450Slc, true, true)
		yys450 := string(yys450Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys450 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				x.MaxUnavailable = pkg6_intstr.IntOrString{}
			} else {
				yyv451 := &x.MaxUnavailable
				yym452 := z.DecBinary()
				_ = yym452
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv451) {
				} else if !yym452 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv451)
				} else {
					z.DecFallback(yyv451, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				x.MaxSurge = pkg6_intstr.IntOrString{}
			} else {
				yyv453 := &x.MaxSurge
				yym454 := z.DecBinary()
				_ = yym454
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv453) {
				} else if !yym454 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv453)
				} else {
					z.DecFallback(yyv453, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys450)
		} // end switch yys450
	} // end for yyj450
	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 yyj456 int
	var yyb456 bool
	var yyhl456 bool = l >= 0
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg6_intstr.IntOrString{}
	} else {
		yyv457 := &x.MaxUnavailable
		yym458 := z.DecBinary()
		_ = yym458
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv457) {
		} else if !yym458 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv457)
		} else {
			z.DecFallback(yyv457, false)
		}
	}
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxSurge = pkg6_intstr.IntOrString{}
	} else {
		yyv459 := &x.MaxSurge
		yym460 := z.DecBinary()
		_ = yym460
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv459) {
		} else if !yym460 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv459)
		} else {
			z.DecFallback(yyv459, false)
		}
	}
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj456++
		if yyhl456 {
			yyb456 = yyj456 > l
		} else {
			yyb456 = r.CheckBreak()
		}
		if yyb456 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj456-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 {
		yym462 := z.EncBinary()
		_ = yym462
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep463 := !z.EncBinary()
			yy2arr463 := z.EncBasicHandle().StructToArray
			var yyq463 [2]bool
			_, _, _ = yysep463, yyq463, yy2arr463
			const yyr463 bool = false
			yyq463[0] = x.Replicas != 0
			yyq463[1] = x.UpdatedReplicas != 0
			var yynn463 int
			if yyr463 || yy2arr463 {
				r.EncodeArrayStart(2)
			} else {
				yynn463 = 0
				for _, b := range yyq463 {
					if b {
						yynn463++
					}
				}
				r.EncodeMapStart(yynn463)
				yynn463 = 0
			}
			if yyr463 || yy2arr463 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq463[0] {
					yym465 := z.EncBinary()
					_ = yym465
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq463[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym466 := z.EncBinary()
					_ = yym466
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr463 || yy2arr463 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq463[1] {
					yym468 := z.EncBinary()
					_ = yym468
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq463[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym469 := z.EncBinary()
					_ = yym469
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr463 || yy2arr463 {
				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
	yym470 := z.DecBinary()
	_ = yym470
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct471 := r.ContainerType()
		if yyct471 == codecSelferValueTypeMap1234 {
			yyl471 := r.ReadMapStart()
			if yyl471 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl471, d)
			}
		} else if yyct471 == codecSelferValueTypeArray1234 {
			yyl471 := r.ReadArrayStart()
			if yyl471 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl471, 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 yys472Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys472Slc
	var yyhl472 bool = l >= 0
	for yyj472 := 0; ; yyj472++ {
		if yyhl472 {
			if yyj472 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys472Slc = r.DecodeBytes(yys472Slc, true, true)
		yys472 := string(yys472Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys472 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys472)
		} // end switch yys472
	} // end for yyj472
	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 yyj475 int
	var yyb475 bool
	var yyhl475 bool = l >= 0
	yyj475++
	if yyhl475 {
		yyb475 = yyj475 > l
	} else {
		yyb475 = r.CheckBreak()
	}
	if yyb475 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj475++
	if yyhl475 {
		yyb475 = yyj475 > l
	} else {
		yyb475 = r.CheckBreak()
	}
	if yyb475 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj475++
		if yyhl475 {
			yyb475 = yyj475 > l
		} else {
			yyb475 = r.CheckBreak()
		}
		if yyb475 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj475-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 {
		yym478 := z.EncBinary()
		_ = yym478
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep479 := !z.EncBinary()
			yy2arr479 := z.EncBasicHandle().StructToArray
			var yyq479 [4]bool
			_, _, _ = yysep479, yyq479, yy2arr479
			const yyr479 bool = false
			yyq479[0] = x.Kind != ""
			yyq479[1] = x.APIVersion != ""
			yyq479[2] = true
			var yynn479 int
			if yyr479 || yy2arr479 {
				r.EncodeArrayStart(4)
			} else {
				yynn479 = 1
				for _, b := range yyq479 {
					if b {
						yynn479++
					}
				}
				r.EncodeMapStart(yynn479)
				yynn479 = 0
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[0] {
					yym481 := z.EncBinary()
					_ = yym481
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym482 := z.EncBinary()
					_ = yym482
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[1] {
					yym484 := z.EncBinary()
					_ = yym484
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym485 := z.EncBinary()
					_ = yym485
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq479[2] {
					yy487 := &x.ListMeta
					yym488 := z.EncBinary()
					_ = yym488
					if false {
					} else if z.HasExtensions() && z.EncExt(yy487) {
					} else {
						z.EncFallback(yy487)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq479[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy489 := &x.ListMeta
					yym490 := z.EncBinary()
					_ = yym490
					if false {
					} else if z.HasExtensions() && z.EncExt(yy489) {
					} else {
						z.EncFallback(yy489)
					}
				}
			}
			if yyr479 || yy2arr479 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym492 := z.EncBinary()
					_ = yym492
					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 {
					yym493 := z.EncBinary()
					_ = yym493
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr479 || yy2arr479 {
				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
	yym494 := z.DecBinary()
	_ = yym494
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct495 := r.ContainerType()
		if yyct495 == codecSelferValueTypeMap1234 {
			yyl495 := r.ReadMapStart()
			if yyl495 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl495, d)
			}
		} else if yyct495 == codecSelferValueTypeArray1234 {
			yyl495 := r.ReadArrayStart()
			if yyl495 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl495, 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 yys496Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys496Slc
	var yyhl496 bool = l >= 0
	for yyj496 := 0; ; yyj496++ {
		if yyhl496 {
			if yyj496 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys496Slc = r.DecodeBytes(yys496Slc, true, true)
		yys496 := string(yys496Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys496 {
		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 {
				yyv499 := &x.ListMeta
				yym500 := z.DecBinary()
				_ = yym500
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv499) {
				} else {
					z.DecFallback(yyv499, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv501 := &x.Items
				yym502 := z.DecBinary()
				_ = yym502
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv501), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys496)
		} // end switch yys496
	} // end for yyj496
	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 yyj503 int
	var yyb503 bool
	var yyhl503 bool = l >= 0
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv506 := &x.ListMeta
		yym507 := z.DecBinary()
		_ = yym507
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv506) {
		} else {
			z.DecFallback(yyv506, false)
		}
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv508 := &x.Items
		yym509 := z.DecBinary()
		_ = yym509
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv508), d)
		}
	}
	for {
		yyj503++
		if yyhl503 {
			yyb503 = yyj503 > l
		} else {
			yyb503 = r.CheckBreak()
		}
		if yyb503 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj503-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 {
		yym510 := z.EncBinary()
		_ = yym510
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep511 := !z.EncBinary()
			yy2arr511 := z.EncBasicHandle().StructToArray
			var yyq511 [2]bool
			_, _, _ = yysep511, yyq511, yy2arr511
			const yyr511 bool = false
			yyq511[0] = x.Type != ""
			yyq511[1] = x.RollingUpdate != nil
			var yynn511 int
			if yyr511 || yy2arr511 {
				r.EncodeArrayStart(2)
			} else {
				yynn511 = 0
				for _, b := range yyq511 {
					if b {
						yynn511++
					}
				}
				r.EncodeMapStart(yynn511)
				yynn511 = 0
			}
			if yyr511 || yy2arr511 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq511[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq511[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr511 || yy2arr511 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq511[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq511[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 yyr511 || yy2arr511 {
				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
	yym514 := z.DecBinary()
	_ = yym514
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct515 := r.ContainerType()
		if yyct515 == codecSelferValueTypeMap1234 {
			yyl515 := r.ReadMapStart()
			if yyl515 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl515, d)
			}
		} else if yyct515 == codecSelferValueTypeArray1234 {
			yyl515 := r.ReadArrayStart()
			if yyl515 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl515, 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 yys516Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys516Slc
	var yyhl516 bool = l >= 0
	for yyj516 := 0; ; yyj516++ {
		if yyhl516 {
			if yyj516 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys516Slc = r.DecodeBytes(yys516Slc, true, true)
		yys516 := string(yys516Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys516 {
		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, yys516)
		} // end switch yys516
	} // end for yyj516
	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 yyj519 int
	var yyb519 bool
	var yyhl519 bool = l >= 0
	yyj519++
	if yyhl519 {
		yyb519 = yyj519 > l
	} else {
		yyb519 = r.CheckBreak()
	}
	if yyb519 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DaemonSetUpdateStrategyType(r.DecodeString())
	}
	yyj519++
	if yyhl519 {
		yyb519 = yyj519 > l
	} else {
		yyb519 = r.CheckBreak()
	}
	if yyb519 {
		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 {
		yyj519++
		if yyhl519 {
			yyb519 = yyj519 > l
		} else {
			yyb519 = r.CheckBreak()
		}
		if yyb519 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj519-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DaemonSetUpdateStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym522 := z.EncBinary()
	_ = yym522
	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
	yym523 := z.DecBinary()
	_ = yym523
	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 {
		yym524 := z.EncBinary()
		_ = yym524
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep525 := !z.EncBinary()
			yy2arr525 := z.EncBasicHandle().StructToArray
			var yyq525 [2]bool
			_, _, _ = yysep525, yyq525, yy2arr525
			const yyr525 bool = false
			yyq525[0] = true
			yyq525[1] = x.MinReadySeconds != 0
			var yynn525 int
			if yyr525 || yy2arr525 {
				r.EncodeArrayStart(2)
			} else {
				yynn525 = 0
				for _, b := range yyq525 {
					if b {
						yynn525++
					}
				}
				r.EncodeMapStart(yynn525)
				yynn525 = 0
			}
			if yyr525 || yy2arr525 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq525[0] {
					yy527 := &x.MaxUnavailable
					yym528 := z.EncBinary()
					_ = yym528
					if false {
					} else if z.HasExtensions() && z.EncExt(yy527) {
					} else if !yym528 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy527)
					} else {
						z.EncFallback(yy527)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq525[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy529 := &x.MaxUnavailable
					yym530 := z.EncBinary()
					_ = yym530
					if false {
					} else if z.HasExtensions() && z.EncExt(yy529) {
					} else if !yym530 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy529)
					} else {
						z.EncFallback(yy529)
					}
				}
			}
			if yyr525 || yy2arr525 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq525[1] {
					yym532 := z.EncBinary()
					_ = yym532
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq525[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym533 := z.EncBinary()
					_ = yym533
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr525 || yy2arr525 {
				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
	yym534 := z.DecBinary()
	_ = yym534
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct535 := r.ContainerType()
		if yyct535 == codecSelferValueTypeMap1234 {
			yyl535 := r.ReadMapStart()
			if yyl535 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl535, d)
			}
		} else if yyct535 == codecSelferValueTypeArray1234 {
			yyl535 := r.ReadArrayStart()
			if yyl535 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl535, 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 yys536Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys536Slc
	var yyhl536 bool = l >= 0
	for yyj536 := 0; ; yyj536++ {
		if yyhl536 {
			if yyj536 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys536Slc = r.DecodeBytes(yys536Slc, true, true)
		yys536 := string(yys536Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys536 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				x.MaxUnavailable = pkg6_intstr.IntOrString{}
			} else {
				yyv537 := &x.MaxUnavailable
				yym538 := z.DecBinary()
				_ = yym538
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv537) {
				} else if !yym538 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv537)
				} else {
					z.DecFallback(yyv537, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys536)
		} // end switch yys536
	} // end for yyj536
	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 yyj540 int
	var yyb540 bool
	var yyhl540 bool = l >= 0
	yyj540++
	if yyhl540 {
		yyb540 = yyj540 > l
	} else {
		yyb540 = r.CheckBreak()
	}
	if yyb540 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg6_intstr.IntOrString{}
	} else {
		yyv541 := &x.MaxUnavailable
		yym542 := z.DecBinary()
		_ = yym542
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv541) {
		} else if !yym542 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv541)
		} else {
			z.DecFallback(yyv541, false)
		}
	}
	yyj540++
	if yyhl540 {
		yyb540 = yyj540 > l
	} else {
		yyb540 = r.CheckBreak()
	}
	if yyb540 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj540++
		if yyhl540 {
			yyb540 = yyj540 > l
		} else {
			yyb540 = r.CheckBreak()
		}
		if yyb540 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj540-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 {
		yym544 := z.EncBinary()
		_ = yym544
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep545 := !z.EncBinary()
			yy2arr545 := z.EncBasicHandle().StructToArray
			var yyq545 [4]bool
			_, _, _ = yysep545, yyq545, yy2arr545
			const yyr545 bool = false
			yyq545[0] = x.Selector != nil
			yyq545[1] = x.Template != nil
			yyq545[2] = true
			yyq545[3] = x.UniqueLabelKey != ""
			var yynn545 int
			if yyr545 || yy2arr545 {
				r.EncodeArrayStart(4)
			} else {
				yynn545 = 0
				for _, b := range yyq545 {
					if b {
						yynn545++
					}
				}
				r.EncodeMapStart(yynn545)
				yynn545 = 0
			}
			if yyr545 || yy2arr545 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq545[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq545[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 yyr545 || yy2arr545 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq545[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq545[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 yyr545 || yy2arr545 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq545[2] {
					yy549 := &x.UpdateStrategy
					yy549.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq545[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updateStrategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy550 := &x.UpdateStrategy
					yy550.CodecEncodeSelf(e)
				}
			}
			if yyr545 || yy2arr545 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq545[3] {
					yym552 := z.EncBinary()
					_ = yym552
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq545[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym553 := z.EncBinary()
					_ = yym553
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				}
			}
			if yyr545 || yy2arr545 {
				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
	yym554 := z.DecBinary()
	_ = yym554
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct555 := r.ContainerType()
		if yyct555 == codecSelferValueTypeMap1234 {
			yyl555 := r.ReadMapStart()
			if yyl555 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl555, d)
			}
		} else if yyct555 == codecSelferValueTypeArray1234 {
			yyl555 := r.ReadArrayStart()
			if yyl555 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl555, 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 yys556Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys556Slc
	var yyhl556 bool = l >= 0
	for yyj556 := 0; ; yyj556++ {
		if yyhl556 {
			if yyj556 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys556Slc = r.DecodeBytes(yys556Slc, true, true)
		yys556 := string(yys556Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys556 {
		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_api.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		case "updateStrategy":
			if r.TryDecodeAsNil() {
				x.UpdateStrategy = DaemonSetUpdateStrategy{}
			} else {
				yyv559 := &x.UpdateStrategy
				yyv559.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				x.UniqueLabelKey = ""
			} else {
				x.UniqueLabelKey = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys556)
		} // end switch yys556
	} // end for yyj556
	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 yyj561 int
	var yyb561 bool
	var yyhl561 bool = l >= 0
	yyj561++
	if yyhl561 {
		yyb561 = yyj561 > l
	} else {
		yyb561 = r.CheckBreak()
	}
	if yyb561 {
		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)
	}
	yyj561++
	if yyhl561 {
		yyb561 = yyj561 > l
	} else {
		yyb561 = r.CheckBreak()
	}
	if yyb561 {
		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_api.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	yyj561++
	if yyhl561 {
		yyb561 = yyj561 > l
	} else {
		yyb561 = r.CheckBreak()
	}
	if yyb561 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdateStrategy = DaemonSetUpdateStrategy{}
	} else {
		yyv564 := &x.UpdateStrategy
		yyv564.CodecDecodeSelf(d)
	}
	yyj561++
	if yyhl561 {
		yyb561 = yyj561 > l
	} else {
		yyb561 = r.CheckBreak()
	}
	if yyb561 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UniqueLabelKey = ""
	} else {
		x.UniqueLabelKey = string(r.DecodeString())
	}
	for {
		yyj561++
		if yyhl561 {
			yyb561 = yyj561 > l
		} else {
			yyb561 = r.CheckBreak()
		}
		if yyb561 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj561-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 {
		yym566 := z.EncBinary()
		_ = yym566
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep567 := !z.EncBinary()
			yy2arr567 := z.EncBasicHandle().StructToArray
			var yyq567 [3]bool
			_, _, _ = yysep567, yyq567, yy2arr567
			const yyr567 bool = false
			var yynn567 int
			if yyr567 || yy2arr567 {
				r.EncodeArrayStart(3)
			} else {
				yynn567 = 3
				for _, b := range yyq567 {
					if b {
						yynn567++
					}
				}
				r.EncodeMapStart(yynn567)
				yynn567 = 0
			}
			if yyr567 || yy2arr567 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym569 := z.EncBinary()
				_ = yym569
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym570 := z.EncBinary()
				_ = yym570
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr567 || yy2arr567 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym572 := z.EncBinary()
				_ = yym572
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym573 := z.EncBinary()
				_ = yym573
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr567 || yy2arr567 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym575 := z.EncBinary()
				_ = yym575
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym576 := z.EncBinary()
				_ = yym576
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr567 || yy2arr567 {
				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
	yym577 := z.DecBinary()
	_ = yym577
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct578 := r.ContainerType()
		if yyct578 == codecSelferValueTypeMap1234 {
			yyl578 := r.ReadMapStart()
			if yyl578 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl578, d)
			}
		} else if yyct578 == codecSelferValueTypeArray1234 {
			yyl578 := r.ReadArrayStart()
			if yyl578 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl578, 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 yys579Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys579Slc
	var yyhl579 bool = l >= 0
	for yyj579 := 0; ; yyj579++ {
		if yyhl579 {
			if yyj579 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys579Slc = r.DecodeBytes(yys579Slc, true, true)
		yys579 := string(yys579Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys579 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys579)
		} // end switch yys579
	} // end for yyj579
	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 yyj583 int
	var yyb583 bool
	var yyhl583 bool = l >= 0
	yyj583++
	if yyhl583 {
		yyb583 = yyj583 > l
	} else {
		yyb583 = r.CheckBreak()
	}
	if yyb583 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj583++
	if yyhl583 {
		yyb583 = yyj583 > l
	} else {
		yyb583 = r.CheckBreak()
	}
	if yyb583 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj583++
	if yyhl583 {
		yyb583 = yyj583 > l
	} else {
		yyb583 = r.CheckBreak()
	}
	if yyb583 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj583++
		if yyhl583 {
			yyb583 = yyj583 > l
		} else {
			yyb583 = r.CheckBreak()
		}
		if yyb583 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj583-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 {
		yym587 := z.EncBinary()
		_ = yym587
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep588 := !z.EncBinary()
			yy2arr588 := z.EncBasicHandle().StructToArray
			var yyq588 [5]bool
			_, _, _ = yysep588, yyq588, yy2arr588
			const yyr588 bool = false
			yyq588[0] = x.Kind != ""
			yyq588[1] = x.APIVersion != ""
			yyq588[2] = true
			yyq588[3] = true
			yyq588[4] = true
			var yynn588 int
			if yyr588 || yy2arr588 {
				r.EncodeArrayStart(5)
			} else {
				yynn588 = 0
				for _, b := range yyq588 {
					if b {
						yynn588++
					}
				}
				r.EncodeMapStart(yynn588)
				yynn588 = 0
			}
			if yyr588 || yy2arr588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq588[0] {
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq588[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym591 := z.EncBinary()
					_ = yym591
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr588 || yy2arr588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq588[1] {
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq588[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym594 := z.EncBinary()
					_ = yym594
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr588 || yy2arr588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq588[2] {
					yy596 := &x.ObjectMeta
					yy596.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq588[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy597 := &x.ObjectMeta
					yy597.CodecEncodeSelf(e)
				}
			}
			if yyr588 || yy2arr588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq588[3] {
					yy599 := &x.Spec
					yy599.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq588[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy600 := &x.Spec
					yy600.CodecEncodeSelf(e)
				}
			}
			if yyr588 || yy2arr588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq588[4] {
					yy602 := &x.Status
					yy602.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq588[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy603 := &x.Status
					yy603.CodecEncodeSelf(e)
				}
			}
			if yyr588 || yy2arr588 {
				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
	yym604 := z.DecBinary()
	_ = yym604
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct605 := r.ContainerType()
		if yyct605 == codecSelferValueTypeMap1234 {
			yyl605 := r.ReadMapStart()
			if yyl605 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl605, d)
			}
		} else if yyct605 == codecSelferValueTypeArray1234 {
			yyl605 := r.ReadArrayStart()
			if yyl605 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl605, 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 yys606Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys606Slc
	var yyhl606 bool = l >= 0
	for yyj606 := 0; ; yyj606++ {
		if yyhl606 {
			if yyj606 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys606Slc = r.DecodeBytes(yys606Slc, true, true)
		yys606 := string(yys606Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys606 {
		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_api.ObjectMeta{}
			} else {
				yyv609 := &x.ObjectMeta
				yyv609.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv610 := &x.Spec
				yyv610.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv611 := &x.Status
				yyv611.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys606)
		} // end switch yys606
	} // end for yyj606
	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 yyj612 int
	var yyb612 bool
	var yyhl612 bool = l >= 0
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv615 := &x.ObjectMeta
		yyv615.CodecDecodeSelf(d)
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv616 := &x.Spec
		yyv616.CodecDecodeSelf(d)
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv617 := &x.Status
		yyv617.CodecDecodeSelf(d)
	}
	for {
		yyj612++
		if yyhl612 {
			yyb612 = yyj612 > l
		} else {
			yyb612 = r.CheckBreak()
		}
		if yyb612 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj612-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 {
		yym618 := z.EncBinary()
		_ = yym618
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep619 := !z.EncBinary()
			yy2arr619 := z.EncBasicHandle().StructToArray
			var yyq619 [4]bool
			_, _, _ = yysep619, yyq619, yy2arr619
			const yyr619 bool = false
			yyq619[0] = x.Kind != ""
			yyq619[1] = x.APIVersion != ""
			yyq619[2] = true
			var yynn619 int
			if yyr619 || yy2arr619 {
				r.EncodeArrayStart(4)
			} else {
				yynn619 = 1
				for _, b := range yyq619 {
					if b {
						yynn619++
					}
				}
				r.EncodeMapStart(yynn619)
				yynn619 = 0
			}
			if yyr619 || yy2arr619 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq619[0] {
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq619[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym622 := z.EncBinary()
					_ = yym622
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr619 || yy2arr619 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq619[1] {
					yym624 := z.EncBinary()
					_ = yym624
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq619[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym625 := z.EncBinary()
					_ = yym625
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr619 || yy2arr619 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq619[2] {
					yy627 := &x.ListMeta
					yym628 := z.EncBinary()
					_ = yym628
					if false {
					} else if z.HasExtensions() && z.EncExt(yy627) {
					} else {
						z.EncFallback(yy627)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq619[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy629 := &x.ListMeta
					yym630 := z.EncBinary()
					_ = yym630
					if false {
					} else if z.HasExtensions() && z.EncExt(yy629) {
					} else {
						z.EncFallback(yy629)
					}
				}
			}
			if yyr619 || yy2arr619 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym632 := z.EncBinary()
					_ = yym632
					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 {
					yym633 := z.EncBinary()
					_ = yym633
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr619 || yy2arr619 {
				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
	yym634 := z.DecBinary()
	_ = yym634
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct635 := r.ContainerType()
		if yyct635 == codecSelferValueTypeMap1234 {
			yyl635 := r.ReadMapStart()
			if yyl635 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl635, d)
			}
		} else if yyct635 == codecSelferValueTypeArray1234 {
			yyl635 := r.ReadArrayStart()
			if yyl635 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl635, 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 yys636Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys636Slc
	var yyhl636 bool = l >= 0
	for yyj636 := 0; ; yyj636++ {
		if yyhl636 {
			if yyj636 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys636Slc = r.DecodeBytes(yys636Slc, true, true)
		yys636 := string(yys636Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys636 {
		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 {
				yyv639 := &x.ListMeta
				yym640 := z.DecBinary()
				_ = yym640
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv639) {
				} else {
					z.DecFallback(yyv639, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv641 := &x.Items
				yym642 := z.DecBinary()
				_ = yym642
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv641), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys636)
		} // end switch yys636
	} // end for yyj636
	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 yyj643 int
	var yyb643 bool
	var yyhl643 bool = l >= 0
	yyj643++
	if yyhl643 {
		yyb643 = yyj643 > l
	} else {
		yyb643 = r.CheckBreak()
	}
	if yyb643 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj643++
	if yyhl643 {
		yyb643 = yyj643 > l
	} else {
		yyb643 = r.CheckBreak()
	}
	if yyb643 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj643++
	if yyhl643 {
		yyb643 = yyj643 > l
	} else {
		yyb643 = r.CheckBreak()
	}
	if yyb643 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv646 := &x.ListMeta
		yym647 := z.DecBinary()
		_ = yym647
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv646) {
		} else {
			z.DecFallback(yyv646, false)
		}
	}
	yyj643++
	if yyhl643 {
		yyb643 = yyj643 > l
	} else {
		yyb643 = r.CheckBreak()
	}
	if yyb643 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv648 := &x.Items
		yym649 := z.DecBinary()
		_ = yym649
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv648), d)
		}
	}
	for {
		yyj643++
		if yyhl643 {
			yyb643 = yyj643 > l
		} else {
			yyb643 = r.CheckBreak()
		}
		if yyb643 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj643-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 {
		yym650 := z.EncBinary()
		_ = yym650
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep651 := !z.EncBinary()
			yy2arr651 := z.EncBasicHandle().StructToArray
			var yyq651 [4]bool
			_, _, _ = yysep651, yyq651, yy2arr651
			const yyr651 bool = false
			yyq651[0] = x.Kind != ""
			yyq651[1] = x.APIVersion != ""
			yyq651[2] = true
			var yynn651 int
			if yyr651 || yy2arr651 {
				r.EncodeArrayStart(4)
			} else {
				yynn651 = 1
				for _, b := range yyq651 {
					if b {
						yynn651++
					}
				}
				r.EncodeMapStart(yynn651)
				yynn651 = 0
			}
			if yyr651 || yy2arr651 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq651[0] {
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq651[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym654 := z.EncBinary()
					_ = yym654
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr651 || yy2arr651 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq651[1] {
					yym656 := z.EncBinary()
					_ = yym656
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq651[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym657 := z.EncBinary()
					_ = yym657
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr651 || yy2arr651 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq651[2] {
					yy659 := &x.ListMeta
					yym660 := z.EncBinary()
					_ = yym660
					if false {
					} else if z.HasExtensions() && z.EncExt(yy659) {
					} else {
						z.EncFallback(yy659)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq651[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy661 := &x.ListMeta
					yym662 := z.EncBinary()
					_ = yym662
					if false {
					} else if z.HasExtensions() && z.EncExt(yy661) {
					} else {
						z.EncFallback(yy661)
					}
				}
			}
			if yyr651 || yy2arr651 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym664 := z.EncBinary()
					_ = yym664
					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 {
					yym665 := z.EncBinary()
					_ = yym665
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr651 || yy2arr651 {
				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
	yym666 := z.DecBinary()
	_ = yym666
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct667 := r.ContainerType()
		if yyct667 == codecSelferValueTypeMap1234 {
			yyl667 := r.ReadMapStart()
			if yyl667 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl667, d)
			}
		} else if yyct667 == codecSelferValueTypeArray1234 {
			yyl667 := r.ReadArrayStart()
			if yyl667 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl667, 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 yys668Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys668Slc
	var yyhl668 bool = l >= 0
	for yyj668 := 0; ; yyj668++ {
		if yyhl668 {
			if yyj668 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys668Slc = r.DecodeBytes(yys668Slc, true, true)
		yys668 := string(yys668Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys668 {
		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 {
				yyv671 := &x.ListMeta
				yym672 := z.DecBinary()
				_ = yym672
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv671) {
				} else {
					z.DecFallback(yyv671, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv673 := &x.Items
				yym674 := z.DecBinary()
				_ = yym674
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv673), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys668)
		} // end switch yys668
	} // end for yyj668
	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 yyj675 int
	var yyb675 bool
	var yyhl675 bool = l >= 0
	yyj675++
	if yyhl675 {
		yyb675 = yyj675 > l
	} else {
		yyb675 = r.CheckBreak()
	}
	if yyb675 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj675++
	if yyhl675 {
		yyb675 = yyj675 > l
	} else {
		yyb675 = r.CheckBreak()
	}
	if yyb675 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj675++
	if yyhl675 {
		yyb675 = yyj675 > l
	} else {
		yyb675 = r.CheckBreak()
	}
	if yyb675 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv678 := &x.ListMeta
		yym679 := z.DecBinary()
		_ = yym679
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv678) {
		} else {
			z.DecFallback(yyv678, false)
		}
	}
	yyj675++
	if yyhl675 {
		yyb675 = yyj675 > l
	} else {
		yyb675 = r.CheckBreak()
	}
	if yyb675 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv680 := &x.Items
		yym681 := z.DecBinary()
		_ = yym681
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv680), d)
		}
	}
	for {
		yyj675++
		if yyhl675 {
			yyb675 = yyj675 > l
		} else {
			yyb675 = r.CheckBreak()
		}
		if yyb675 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj675-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 {
		yym682 := z.EncBinary()
		_ = yym682
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep683 := !z.EncBinary()
			yy2arr683 := z.EncBasicHandle().StructToArray
			var yyq683 [5]bool
			_, _, _ = yysep683, yyq683, yy2arr683
			const yyr683 bool = false
			yyq683[0] = x.Kind != ""
			yyq683[1] = x.APIVersion != ""
			yyq683[2] = true
			yyq683[3] = true
			yyq683[4] = true
			var yynn683 int
			if yyr683 || yy2arr683 {
				r.EncodeArrayStart(5)
			} else {
				yynn683 = 0
				for _, b := range yyq683 {
					if b {
						yynn683++
					}
				}
				r.EncodeMapStart(yynn683)
				yynn683 = 0
			}
			if yyr683 || yy2arr683 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq683[0] {
					yym685 := z.EncBinary()
					_ = yym685
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq683[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym686 := z.EncBinary()
					_ = yym686
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr683 || yy2arr683 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq683[1] {
					yym688 := z.EncBinary()
					_ = yym688
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq683[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym689 := z.EncBinary()
					_ = yym689
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr683 || yy2arr683 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq683[2] {
					yy691 := &x.ObjectMeta
					yy691.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq683[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy692 := &x.ObjectMeta
					yy692.CodecEncodeSelf(e)
				}
			}
			if yyr683 || yy2arr683 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq683[3] {
					yy694 := &x.Spec
					yy694.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq683[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy695 := &x.Spec
					yy695.CodecEncodeSelf(e)
				}
			}
			if yyr683 || yy2arr683 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq683[4] {
					yy697 := &x.Status
					yy697.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq683[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy698 := &x.Status
					yy698.CodecEncodeSelf(e)
				}
			}
			if yyr683 || yy2arr683 {
				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
	yym699 := z.DecBinary()
	_ = yym699
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct700 := r.ContainerType()
		if yyct700 == codecSelferValueTypeMap1234 {
			yyl700 := r.ReadMapStart()
			if yyl700 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl700, d)
			}
		} else if yyct700 == codecSelferValueTypeArray1234 {
			yyl700 := r.ReadArrayStart()
			if yyl700 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl700, 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 yys701Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys701Slc
	var yyhl701 bool = l >= 0
	for yyj701 := 0; ; yyj701++ {
		if yyhl701 {
			if yyj701 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys701Slc = r.DecodeBytes(yys701Slc, true, true)
		yys701 := string(yys701Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys701 {
		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_api.ObjectMeta{}
			} else {
				yyv704 := &x.ObjectMeta
				yyv704.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv705 := &x.Spec
				yyv705.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv706 := &x.Status
				yyv706.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys701)
		} // end switch yys701
	} // end for yyj701
	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 yyj707 int
	var yyb707 bool
	var yyhl707 bool = l >= 0
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv710 := &x.ObjectMeta
		yyv710.CodecDecodeSelf(d)
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv711 := &x.Spec
		yyv711.CodecDecodeSelf(d)
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv712 := &x.Status
		yyv712.CodecDecodeSelf(d)
	}
	for {
		yyj707++
		if yyhl707 {
			yyb707 = yyj707 > l
		} else {
			yyb707 = r.CheckBreak()
		}
		if yyb707 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj707-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 {
		yym713 := z.EncBinary()
		_ = yym713
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep714 := !z.EncBinary()
			yy2arr714 := z.EncBasicHandle().StructToArray
			var yyq714 [4]bool
			_, _, _ = yysep714, yyq714, yy2arr714
			const yyr714 bool = false
			yyq714[0] = x.Kind != ""
			yyq714[1] = x.APIVersion != ""
			yyq714[2] = true
			var yynn714 int
			if yyr714 || yy2arr714 {
				r.EncodeArrayStart(4)
			} else {
				yynn714 = 1
				for _, b := range yyq714 {
					if b {
						yynn714++
					}
				}
				r.EncodeMapStart(yynn714)
				yynn714 = 0
			}
			if yyr714 || yy2arr714 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq714[0] {
					yym716 := z.EncBinary()
					_ = yym716
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq714[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym717 := z.EncBinary()
					_ = yym717
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr714 || yy2arr714 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq714[1] {
					yym719 := z.EncBinary()
					_ = yym719
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq714[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym720 := z.EncBinary()
					_ = yym720
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr714 || yy2arr714 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq714[2] {
					yy722 := &x.ListMeta
					yym723 := z.EncBinary()
					_ = yym723
					if false {
					} else if z.HasExtensions() && z.EncExt(yy722) {
					} else {
						z.EncFallback(yy722)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq714[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy724 := &x.ListMeta
					yym725 := z.EncBinary()
					_ = yym725
					if false {
					} else if z.HasExtensions() && z.EncExt(yy724) {
					} else {
						z.EncFallback(yy724)
					}
				}
			}
			if yyr714 || yy2arr714 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym727 := z.EncBinary()
					_ = yym727
					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 {
					yym728 := z.EncBinary()
					_ = yym728
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yyr714 || yy2arr714 {
				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
	yym729 := z.DecBinary()
	_ = yym729
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct730 := r.ContainerType()
		if yyct730 == codecSelferValueTypeMap1234 {
			yyl730 := r.ReadMapStart()
			if yyl730 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl730, d)
			}
		} else if yyct730 == codecSelferValueTypeArray1234 {
			yyl730 := r.ReadArrayStart()
			if yyl730 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl730, 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 yys731Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys731Slc
	var yyhl731 bool = l >= 0
	for yyj731 := 0; ; yyj731++ {
		if yyhl731 {
			if yyj731 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys731Slc = r.DecodeBytes(yys731Slc, true, true)
		yys731 := string(yys731Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys731 {
		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 {
				yyv734 := &x.ListMeta
				yym735 := z.DecBinary()
				_ = yym735
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv734) {
				} else {
					z.DecFallback(yyv734, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv736 := &x.Items
				yym737 := z.DecBinary()
				_ = yym737
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv736), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys731)
		} // end switch yys731
	} // end for yyj731
	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 yyj738 int
	var yyb738 bool
	var yyhl738 bool = l >= 0
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv741 := &x.ListMeta
		yym742 := z.DecBinary()
		_ = yym742
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv741) {
		} else {
			z.DecFallback(yyv741, false)
		}
	}
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv743 := &x.Items
		yym744 := z.DecBinary()
		_ = yym744
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv743), d)
		}
	}
	for {
		yyj738++
		if yyhl738 {
			yyb738 = yyj738 > l
		} else {
			yyb738 = r.CheckBreak()
		}
		if yyb738 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj738-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 {
		yym745 := z.EncBinary()
		_ = yym745
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep746 := !z.EncBinary()
			yy2arr746 := z.EncBasicHandle().StructToArray
			var yyq746 [5]bool
			_, _, _ = yysep746, yyq746, yy2arr746
			const yyr746 bool = false
			yyq746[0] = x.Parallelism != nil
			yyq746[1] = x.Completions != nil
			yyq746[2] = x.ActiveDeadlineSeconds != nil
			yyq746[3] = x.Selector != nil
			var yynn746 int
			if yyr746 || yy2arr746 {
				r.EncodeArrayStart(5)
			} else {
				yynn746 = 1
				for _, b := range yyq746 {
					if b {
						yynn746++
					}
				}
				r.EncodeMapStart(yynn746)
				yynn746 = 0
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq746[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy748 := *x.Parallelism
						yym749 := z.EncBinary()
						_ = yym749
						if false {
						} else {
							r.EncodeInt(int64(yy748))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq746[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy750 := *x.Parallelism
						yym751 := z.EncBinary()
						_ = yym751
						if false {
						} else {
							r.EncodeInt(int64(yy750))
						}
					}
				}
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq746[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy753 := *x.Completions
						yym754 := z.EncBinary()
						_ = yym754
						if false {
						} else {
							r.EncodeInt(int64(yy753))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq746[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy755 := *x.Completions
						yym756 := z.EncBinary()
						_ = yym756
						if false {
						} else {
							r.EncodeInt(int64(yy755))
						}
					}
				}
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq746[2] {
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy758 := *x.ActiveDeadlineSeconds
						yym759 := z.EncBinary()
						_ = yym759
						if false {
						} else {
							r.EncodeInt(int64(yy758))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq746[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy760 := *x.ActiveDeadlineSeconds
						yym761 := z.EncBinary()
						_ = yym761
						if false {
						} else {
							r.EncodeInt(int64(yy760))
						}
					}
				}
			}
			if yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq746[3] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq746[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 yyr746 || yy2arr746 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy764 := &x.Template
				yy764.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy765 := &x.Template
				yy765.CodecEncodeSelf(e)
			}
			if yyr746 || yy2arr746 {
				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
	yym766 := z.DecBinary()
	_ = yym766
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct767 := r.ContainerType()
		if yyct767 == codecSelferValueTypeMap1234 {
			yyl767 := r.ReadMapStart()
			if yyl767 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl767, d)
			}
		} else if yyct767 == codecSelferValueTypeArray1234 {
			yyl767 := r.ReadArrayStart()
			if yyl767 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl767, 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 yys768Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys768Slc
	var yyhl768 bool = l >= 0
	for yyj768 := 0; ; yyj768++ {
		if yyhl768 {
			if yyj768 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys768Slc = r.DecodeBytes(yys768Slc, true, true)
		yys768 := string(yys768Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys768 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int)
				}
				yym770 := z.DecBinary()
				_ = yym770
				if false {
				} else {
					*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "completions":
			if r.TryDecodeAsNil() {
				if x.Completions != nil {
					x.Completions = nil
				}
			} else {
				if x.Completions == nil {
					x.Completions = new(int)
				}
				yym772 := z.DecBinary()
				_ = yym772
				if false {
				} else {
					*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "activeDeadlineSeconds":
			if r.TryDecodeAsNil() {
				if x.ActiveDeadlineSeconds != nil {
					x.ActiveDeadlineSeconds = nil
				}
			} else {
				if x.ActiveDeadlineSeconds == nil {
					x.ActiveDeadlineSeconds = new(int64)
				}
				yym774 := z.DecBinary()
				_ = yym774
				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_api.PodTemplateSpec{}
			} else {
				yyv776 := &x.Template
				yyv776.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys768)
		} // end switch yys768
	} // end for yyj768
	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 yyj777 int
	var yyb777 bool
	var yyhl777 bool = l >= 0
	yyj777++
	if yyhl777 {
		yyb777 = yyj777 > l
	} else {
		yyb777 = r.CheckBreak()
	}
	if yyb777 {
		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(int)
		}
		yym779 := z.DecBinary()
		_ = yym779
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj777++
	if yyhl777 {
		yyb777 = yyj777 > l
	} else {
		yyb777 = r.CheckBreak()
	}
	if yyb777 {
		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(int)
		}
		yym781 := z.DecBinary()
		_ = yym781
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj777++
	if yyhl777 {
		yyb777 = yyj777 > l
	} else {
		yyb777 = r.CheckBreak()
	}
	if yyb777 {
		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)
		}
		yym783 := z.DecBinary()
		_ = yym783
		if false {
		} else {
			*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj777++
	if yyhl777 {
		yyb777 = yyj777 > l
	} else {
		yyb777 = r.CheckBreak()
	}
	if yyb777 {
		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)
	}
	yyj777++
	if yyhl777 {
		yyb777 = yyj777 > l
	} else {
		yyb777 = r.CheckBreak()
	}
	if yyb777 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv785 := &x.Template
		yyv785.CodecDecodeSelf(d)
	}
	for {
		yyj777++
		if yyhl777 {
			yyb777 = yyj777 > l
		} else {
			yyb777 = r.CheckBreak()
		}
		if yyb777 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj777-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 {
		yym786 := z.EncBinary()
		_ = yym786
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep787 := !z.EncBinary()
			yy2arr787 := z.EncBasicHandle().StructToArray
			var yyq787 [6]bool
			_, _, _ = yysep787, yyq787, yy2arr787
			const yyr787 bool = false
			yyq787[0] = len(x.Conditions) != 0
			yyq787[1] = x.StartTime != nil
			yyq787[2] = x.CompletionTime != nil
			yyq787[3] = x.Active != 0
			yyq787[4] = x.Succeeded != 0
			yyq787[5] = x.Failed != 0
			var yynn787 int
			if yyr787 || yy2arr787 {
				r.EncodeArrayStart(6)
			} else {
				yynn787 = 0
				for _, b := range yyq787 {
					if b {
						yynn787++
					}
				}
				r.EncodeMapStart(yynn787)
				yynn787 = 0
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym789 := z.EncBinary()
						_ = yym789
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq787[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym790 := z.EncBinary()
						_ = yym790
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym792 := z.EncBinary()
						_ = yym792
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym792 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym792 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq787[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym793 := z.EncBinary()
						_ = yym793
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym793 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym793 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym795 := z.EncBinary()
						_ = yym795
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym795 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym795 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq787[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym796 := z.EncBinary()
						_ = yym796
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym796 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym796 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[3] {
					yym798 := z.EncBinary()
					_ = yym798
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq787[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym799 := z.EncBinary()
					_ = yym799
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[4] {
					yym801 := z.EncBinary()
					_ = yym801
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq787[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym802 := z.EncBinary()
					_ = yym802
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr787 || yy2arr787 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq787[5] {
					yym804 := z.EncBinary()
					_ = yym804
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq787[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yyr787 || yy2arr787 {
				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
	yym806 := z.DecBinary()
	_ = yym806
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct807 := r.ContainerType()
		if yyct807 == codecSelferValueTypeMap1234 {
			yyl807 := r.ReadMapStart()
			if yyl807 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl807, d)
			}
		} else if yyct807 == codecSelferValueTypeArray1234 {
			yyl807 := r.ReadArrayStart()
			if yyl807 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl807, 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 yys808Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys808Slc
	var yyhl808 bool = l >= 0
	for yyj808 := 0; ; yyj808++ {
		if yyhl808 {
			if yyj808 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys808Slc = r.DecodeBytes(yys808Slc, true, true)
		yys808 := string(yys808Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys808 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv809 := &x.Conditions
				yym810 := z.DecBinary()
				_ = yym810
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv809), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym812 := z.DecBinary()
				_ = yym812
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym812 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym812 && 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)
				}
				yym814 := z.DecBinary()
				_ = yym814
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym814 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym814 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.CompletionTime)
				} else {
					z.DecFallback(x.CompletionTime, false)
				}
			}
		case "active":
			if r.TryDecodeAsNil() {
				x.Active = 0
			} else {
				x.Active = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "succeeded":
			if r.TryDecodeAsNil() {
				x.Succeeded = 0
			} else {
				x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "failed":
			if r.TryDecodeAsNil() {
				x.Failed = 0
			} else {
				x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys808)
		} // end switch yys808
	} // end for yyj808
	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 yyj818 int
	var yyb818 bool
	var yyhl818 bool = l >= 0
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv819 := &x.Conditions
		yym820 := z.DecBinary()
		_ = yym820
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv819), d)
		}
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		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)
		}
		yym822 := z.DecBinary()
		_ = yym822
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym822 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym822 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		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)
		}
		yym824 := z.DecBinary()
		_ = yym824
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym824 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym824 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj818++
		if yyhl818 {
			yyb818 = yyj818 > l
		} else {
			yyb818 = r.CheckBreak()
		}
		if yyb818 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj818-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym828 := z.EncBinary()
	_ = yym828
	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
	yym829 := z.DecBinary()
	_ = yym829
	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 {
		yym830 := z.EncBinary()
		_ = yym830
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep831 := !z.EncBinary()
			yy2arr831 := z.EncBasicHandle().StructToArray
			var yyq831 [6]bool
			_, _, _ = yysep831, yyq831, yy2arr831
			const yyr831 bool = false
			yyq831[2] = true
			yyq831[3] = true
			yyq831[4] = x.Reason != ""
			yyq831[5] = x.Message != ""
			var yynn831 int
			if yyr831 || yy2arr831 {
				r.EncodeArrayStart(6)
			} else {
				yynn831 = 2
				for _, b := range yyq831 {
					if b {
						yynn831++
					}
				}
				r.EncodeMapStart(yynn831)
				yynn831 = 0
			}
			if yyr831 || yy2arr831 {
				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 yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym834 := z.EncBinary()
				_ = yym834
				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)
				yym835 := z.EncBinary()
				_ = yym835
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[2] {
					yy837 := &x.LastProbeTime
					yym838 := z.EncBinary()
					_ = yym838
					if false {
					} else if z.HasExtensions() && z.EncExt(yy837) {
					} else if yym838 {
						z.EncBinaryMarshal(yy837)
					} else if !yym838 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy837)
					} else {
						z.EncFallback(yy837)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy839 := &x.LastProbeTime
					yym840 := z.EncBinary()
					_ = yym840
					if false {
					} else if z.HasExtensions() && z.EncExt(yy839) {
					} else if yym840 {
						z.EncBinaryMarshal(yy839)
					} else if !yym840 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy839)
					} else {
						z.EncFallback(yy839)
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[3] {
					yy842 := &x.LastTransitionTime
					yym843 := z.EncBinary()
					_ = yym843
					if false {
					} else if z.HasExtensions() && z.EncExt(yy842) {
					} else if yym843 {
						z.EncBinaryMarshal(yy842)
					} else if !yym843 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy842)
					} else {
						z.EncFallback(yy842)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy844 := &x.LastTransitionTime
					yym845 := z.EncBinary()
					_ = yym845
					if false {
					} else if z.HasExtensions() && z.EncExt(yy844) {
					} else if yym845 {
						z.EncBinaryMarshal(yy844)
					} else if !yym845 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy844)
					} else {
						z.EncFallback(yy844)
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[4] {
					yym847 := z.EncBinary()
					_ = yym847
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym848 := z.EncBinary()
					_ = yym848
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[5] {
					yym850 := z.EncBinary()
					_ = yym850
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym851 := z.EncBinary()
					_ = yym851
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr831 || yy2arr831 {
				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
	yym852 := z.DecBinary()
	_ = yym852
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct853 := r.ContainerType()
		if yyct853 == codecSelferValueTypeMap1234 {
			yyl853 := r.ReadMapStart()
			if yyl853 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl853, d)
			}
		} else if yyct853 == codecSelferValueTypeArray1234 {
			yyl853 := r.ReadArrayStart()
			if yyl853 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl853, 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 yys854Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys854Slc
	var yyhl854 bool = l >= 0
	for yyj854 := 0; ; yyj854++ {
		if yyhl854 {
			if yyj854 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys854Slc = r.DecodeBytes(yys854Slc, true, true)
		yys854 := string(yys854Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys854 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = JobConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_api.ConditionStatus(r.DecodeString())
			}
		case "lastProbeTime":
			if r.TryDecodeAsNil() {
				x.LastProbeTime = pkg1_unversioned.Time{}
			} else {
				yyv857 := &x.LastProbeTime
				yym858 := z.DecBinary()
				_ = yym858
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv857) {
				} else if yym858 {
					z.DecBinaryUnmarshal(yyv857)
				} else if !yym858 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv857)
				} else {
					z.DecFallback(yyv857, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv859 := &x.LastTransitionTime
				yym860 := z.DecBinary()
				_ = yym860
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv859) {
				} else if yym860 {
					z.DecBinaryUnmarshal(yyv859)
				} else if !yym860 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv859)
				} else {
					z.DecFallback(yyv859, 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, yys854)
		} // end switch yys854
	} // end for yyj854
	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 yyj863 int
	var yyb863 bool
	var yyhl863 bool = l >= 0
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_api.ConditionStatus(r.DecodeString())
	}
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv866 := &x.LastProbeTime
		yym867 := z.DecBinary()
		_ = yym867
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv866) {
		} else if yym867 {
			z.DecBinaryUnmarshal(yyv866)
		} else if !yym867 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv866)
		} else {
			z.DecFallback(yyv866, false)
		}
	}
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv868 := &x.LastTransitionTime
		yym869 := z.DecBinary()
		_ = yym869
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv868) {
		} else if yym869 {
			z.DecBinaryUnmarshal(yyv868)
		} else if !yym869 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv868)
		} else {
			z.DecFallback(yyv868, false)
		}
	}
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj863++
	if yyhl863 {
		yyb863 = yyj863 > l
	} else {
		yyb863 = r.CheckBreak()
	}
	if yyb863 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj863++
		if yyhl863 {
			yyb863 = yyj863 > l
		} else {
			yyb863 = r.CheckBreak()
		}
		if yyb863 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj863-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 {
		yym872 := z.EncBinary()
		_ = yym872
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep873 := !z.EncBinary()
			yy2arr873 := z.EncBasicHandle().StructToArray
			var yyq873 [5]bool
			_, _, _ = yysep873, yyq873, yy2arr873
			const yyr873 bool = false
			yyq873[0] = x.Kind != ""
			yyq873[1] = x.APIVersion != ""
			yyq873[2] = true
			yyq873[3] = true
			yyq873[4] = true
			var yynn873 int
			if yyr873 || yy2arr873 {
				r.EncodeArrayStart(5)
			} else {
				yynn873 = 0
				for _, b := range yyq873 {
					if b {
						yynn873++
					}
				}
				r.EncodeMapStart(yynn873)
				yynn873 = 0
			}
			if yyr873 || yy2arr873 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq873[0] {
					yym875 := z.EncBinary()
					_ = yym875
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq873[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym876 := z.EncBinary()
					_ = yym876
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr873 || yy2arr873 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq873[1] {
					yym878 := z.EncBinary()
					_ = yym878
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq873[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym879 := z.EncBinary()
					_ = yym879
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr873 || yy2arr873 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq873[2] {
					yy881 := &x.ObjectMeta
					yy881.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq873[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy882 := &x.ObjectMeta
					yy882.CodecEncodeSelf(e)
				}
			}
			if yyr873 || yy2arr873 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq873[3] {
					yy884 := &x.Spec
					yy884.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq873[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy885 := &x.Spec
					yy885.CodecEncodeSelf(e)
				}
			}
			if yyr873 || yy2arr873 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq873[4] {
					yy887 := &x.Status
					yy887.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq873[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy888 := &x.Status
					yy888.CodecEncodeSelf(e)
				}
			}
			if yyr873 || yy2arr873 {
				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
	yym889 := z.DecBinary()
	_ = yym889
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct890 := r.ContainerType()
		if yyct890 == codecSelferValueTypeMap1234 {
			yyl890 := r.ReadMapStart()
			if yyl890 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl890, d)
			}
		} else if yyct890 == codecSelferValueTypeArray1234 {
			yyl890 := r.ReadArrayStart()
			if yyl890 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl890, 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 yys891Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys891Slc
	var yyhl891 bool = l >= 0
	for yyj891 := 0; ; yyj891++ {
		if yyhl891 {
			if yyj891 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys891Slc = r.DecodeBytes(yys891Slc, true, true)
		yys891 := string(yys891Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys891 {
		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_api.ObjectMeta{}
			} else {
				yyv894 := &x.ObjectMeta
				yyv894.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv895 := &x.Spec
				yyv895.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv896 := &x.Status
				yyv896.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys891)
		} // end switch yys891
	} // end for yyj891
	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 yyj897 int
	var yyb897 bool
	var yyhl897 bool = l >= 0
	yyj897++
	if yyhl897 {
		yyb897 = yyj897 > l
	} else {
		yyb897 = r.CheckBreak()
	}
	if yyb897 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj897++
	if yyhl897 {
		yyb897 = yyj897 > l
	} else {
		yyb897 = r.CheckBreak()
	}
	if yyb897 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj897++
	if yyhl897 {
		yyb897 = yyj897 > l
	} else {
		yyb897 = r.CheckBreak()
	}
	if yyb897 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv900 := &x.ObjectMeta
		yyv900.CodecDecodeSelf(d)
	}
	yyj897++
	if yyhl897 {
		yyb897 = yyj897 > l
	} else {
		yyb897 = r.CheckBreak()
	}
	if yyb897 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv901 := &x.Spec
		yyv901.CodecDecodeSelf(d)
	}
	yyj897++
	if yyhl897 {
		yyb897 = yyj897 > l
	} else {
		yyb897 = r.CheckBreak()
	}
	if yyb897 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv902 := &x.Status
		yyv902.CodecDecodeSelf(d)
	}
	for {
		yyj897++
		if yyhl897 {
			yyb897 = yyj897 > l
		} else {
			yyb897 = r.CheckBreak()
		}
		if yyb897 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj897-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 {
		yym903 := z.EncBinary()
		_ = yym903
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep904 := !z.EncBinary()
			yy2arr904 := z.EncBasicHandle().StructToArray
			var yyq904 [4]bool
			_, _, _ = yysep904, yyq904, yy2arr904
			const yyr904 bool = false
			yyq904[0] = x.Kind != ""
			yyq904[1] = x.APIVersion != ""
			yyq904[2] = true
			var yynn904 int
			if yyr904 || yy2arr904 {
				r.EncodeArrayStart(4)
			} else {
				yynn904 = 1
				for _, b := range yyq904 {
					if b {
						yynn904++
					}
				}
				r.EncodeMapStart(yynn904)
				yynn904 = 0
			}
			if yyr904 || yy2arr904 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq904[0] {
					yym906 := z.EncBinary()
					_ = yym906
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq904[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym907 := z.EncBinary()
					_ = yym907
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr904 || yy2arr904 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq904[1] {
					yym909 := z.EncBinary()
					_ = yym909
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq904[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym910 := z.EncBinary()
					_ = yym910
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr904 || yy2arr904 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq904[2] {
					yy912 := &x.ListMeta
					yym913 := z.EncBinary()
					_ = yym913
					if false {
					} else if z.HasExtensions() && z.EncExt(yy912) {
					} else {
						z.EncFallback(yy912)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq904[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy914 := &x.ListMeta
					yym915 := z.EncBinary()
					_ = yym915
					if false {
					} else if z.HasExtensions() && z.EncExt(yy914) {
					} else {
						z.EncFallback(yy914)
					}
				}
			}
			if yyr904 || yy2arr904 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym917 := z.EncBinary()
					_ = yym917
					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 {
					yym918 := z.EncBinary()
					_ = yym918
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr904 || yy2arr904 {
				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
	yym919 := z.DecBinary()
	_ = yym919
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct920 := r.ContainerType()
		if yyct920 == codecSelferValueTypeMap1234 {
			yyl920 := r.ReadMapStart()
			if yyl920 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl920, d)
			}
		} else if yyct920 == codecSelferValueTypeArray1234 {
			yyl920 := r.ReadArrayStart()
			if yyl920 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl920, 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 yys921Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys921Slc
	var yyhl921 bool = l >= 0
	for yyj921 := 0; ; yyj921++ {
		if yyhl921 {
			if yyj921 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys921Slc = r.DecodeBytes(yys921Slc, true, true)
		yys921 := string(yys921Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys921 {
		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 {
				yyv924 := &x.ListMeta
				yym925 := z.DecBinary()
				_ = yym925
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv924) {
				} else {
					z.DecFallback(yyv924, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv926 := &x.Items
				yym927 := z.DecBinary()
				_ = yym927
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv926), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys921)
		} // end switch yys921
	} // end for yyj921
	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 yyj928 int
	var yyb928 bool
	var yyhl928 bool = l >= 0
	yyj928++
	if yyhl928 {
		yyb928 = yyj928 > l
	} else {
		yyb928 = r.CheckBreak()
	}
	if yyb928 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj928++
	if yyhl928 {
		yyb928 = yyj928 > l
	} else {
		yyb928 = r.CheckBreak()
	}
	if yyb928 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj928++
	if yyhl928 {
		yyb928 = yyj928 > l
	} else {
		yyb928 = r.CheckBreak()
	}
	if yyb928 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv931 := &x.ListMeta
		yym932 := z.DecBinary()
		_ = yym932
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv931) {
		} else {
			z.DecFallback(yyv931, false)
		}
	}
	yyj928++
	if yyhl928 {
		yyb928 = yyj928 > l
	} else {
		yyb928 = r.CheckBreak()
	}
	if yyb928 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv933 := &x.Items
		yym934 := z.DecBinary()
		_ = yym934
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv933), d)
		}
	}
	for {
		yyj928++
		if yyhl928 {
			yyb928 = yyj928 > l
		} else {
			yyb928 = r.CheckBreak()
		}
		if yyb928 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj928-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 {
		yym935 := z.EncBinary()
		_ = yym935
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep936 := !z.EncBinary()
			yy2arr936 := z.EncBasicHandle().StructToArray
			var yyq936 [2]bool
			_, _, _ = yysep936, yyq936, yy2arr936
			const yyr936 bool = false
			yyq936[0] = x.Backend != nil
			yyq936[1] = len(x.Rules) != 0
			var yynn936 int
			if yyr936 || yy2arr936 {
				r.EncodeArrayStart(2)
			} else {
				yynn936 = 0
				for _, b := range yyq936 {
					if b {
						yynn936++
					}
				}
				r.EncodeMapStart(yynn936)
				yynn936 = 0
			}
			if yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq936[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 yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym939 := z.EncBinary()
						_ = yym939
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq936[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym940 := z.EncBinary()
						_ = yym940
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr936 || yy2arr936 {
				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
	yym941 := z.DecBinary()
	_ = yym941
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct942 := r.ContainerType()
		if yyct942 == codecSelferValueTypeMap1234 {
			yyl942 := r.ReadMapStart()
			if yyl942 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl942, d)
			}
		} else if yyct942 == codecSelferValueTypeArray1234 {
			yyl942 := r.ReadArrayStart()
			if yyl942 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl942, 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 yys943Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys943Slc
	var yyhl943 bool = l >= 0
	for yyj943 := 0; ; yyj943++ {
		if yyhl943 {
			if yyj943 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys943Slc = r.DecodeBytes(yys943Slc, true, true)
		yys943 := string(yys943Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys943 {
		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 {
				yyv945 := &x.Rules
				yym946 := z.DecBinary()
				_ = yym946
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv945), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys943)
		} // end switch yys943
	} // end for yyj943
	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 yyj947 int
	var yyb947 bool
	var yyhl947 bool = l >= 0
	yyj947++
	if yyhl947 {
		yyb947 = yyj947 > l
	} else {
		yyb947 = r.CheckBreak()
	}
	if yyb947 {
		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)
	}
	yyj947++
	if yyhl947 {
		yyb947 = yyj947 > l
	} else {
		yyb947 = r.CheckBreak()
	}
	if yyb947 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv949 := &x.Rules
		yym950 := z.DecBinary()
		_ = yym950
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv949), d)
		}
	}
	for {
		yyj947++
		if yyhl947 {
			yyb947 = yyj947 > l
		} else {
			yyb947 = r.CheckBreak()
		}
		if yyb947 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj947-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 {
		yym951 := z.EncBinary()
		_ = yym951
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep952 := !z.EncBinary()
			yy2arr952 := z.EncBasicHandle().StructToArray
			var yyq952 [1]bool
			_, _, _ = yysep952, yyq952, yy2arr952
			const yyr952 bool = false
			yyq952[0] = true
			var yynn952 int
			if yyr952 || yy2arr952 {
				r.EncodeArrayStart(1)
			} else {
				yynn952 = 0
				for _, b := range yyq952 {
					if b {
						yynn952++
					}
				}
				r.EncodeMapStart(yynn952)
				yynn952 = 0
			}
			if yyr952 || yy2arr952 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq952[0] {
					yy954 := &x.LoadBalancer
					yy954.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq952[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy955 := &x.LoadBalancer
					yy955.CodecEncodeSelf(e)
				}
			}
			if yyr952 || yy2arr952 {
				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
	yym956 := z.DecBinary()
	_ = yym956
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct957 := r.ContainerType()
		if yyct957 == codecSelferValueTypeMap1234 {
			yyl957 := r.ReadMapStart()
			if yyl957 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl957, d)
			}
		} else if yyct957 == codecSelferValueTypeArray1234 {
			yyl957 := r.ReadArrayStart()
			if yyl957 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl957, 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 yys958Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys958Slc
	var yyhl958 bool = l >= 0
	for yyj958 := 0; ; yyj958++ {
		if yyhl958 {
			if yyj958 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys958Slc = r.DecodeBytes(yys958Slc, true, true)
		yys958 := string(yys958Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys958 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
			} else {
				yyv959 := &x.LoadBalancer
				yyv959.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys958)
		} // end switch yys958
	} // end for yyj958
	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 yyj960 int
	var yyb960 bool
	var yyhl960 bool = l >= 0
	yyj960++
	if yyhl960 {
		yyb960 = yyj960 > l
	} else {
		yyb960 = r.CheckBreak()
	}
	if yyb960 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv961 := &x.LoadBalancer
		yyv961.CodecDecodeSelf(d)
	}
	for {
		yyj960++
		if yyhl960 {
			yyb960 = yyj960 > l
		} else {
			yyb960 = r.CheckBreak()
		}
		if yyb960 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj960-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 {
		yym962 := z.EncBinary()
		_ = yym962
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep963 := !z.EncBinary()
			yy2arr963 := z.EncBasicHandle().StructToArray
			var yyq963 [2]bool
			_, _, _ = yysep963, yyq963, yy2arr963
			const yyr963 bool = false
			yyq963[0] = x.Host != ""
			yyq963[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn963 int
			if yyr963 || yy2arr963 {
				r.EncodeArrayStart(2)
			} else {
				yynn963 = 0
				for _, b := range yyq963 {
					if b {
						yynn963++
					}
				}
				r.EncodeMapStart(yynn963)
				yynn963 = 0
			}
			if yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq963[0] {
					yym965 := z.EncBinary()
					_ = yym965
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq963[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym966 := z.EncBinary()
					_ = yym966
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn967 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn967 = true
				goto LABEL967
			}
		LABEL967:
			if yyr963 || yy2arr963 {
				if yyn967 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq963[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq963[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn967 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr963 || yy2arr963 {
				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
	yym968 := z.DecBinary()
	_ = yym968
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct969 := r.ContainerType()
		if yyct969 == codecSelferValueTypeMap1234 {
			yyl969 := r.ReadMapStart()
			if yyl969 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl969, d)
			}
		} else if yyct969 == codecSelferValueTypeArray1234 {
			yyl969 := r.ReadArrayStart()
			if yyl969 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl969, 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 yys970Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys970Slc
	var yyhl970 bool = l >= 0
	for yyj970 := 0; ; yyj970++ {
		if yyhl970 {
			if yyj970 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys970Slc = r.DecodeBytes(yys970Slc, true, true)
		yys970 := string(yys970Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys970 {
		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, yys970)
		} // end switch yys970
	} // end for yyj970
	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 yyj973 int
	var yyb973 bool
	var yyhl973 bool = l >= 0
	yyj973++
	if yyhl973 {
		yyb973 = yyj973 > l
	} else {
		yyb973 = r.CheckBreak()
	}
	if yyb973 {
		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)
	}
	yyj973++
	if yyhl973 {
		yyb973 = yyj973 > l
	} else {
		yyb973 = r.CheckBreak()
	}
	if yyb973 {
		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 {
		yyj973++
		if yyhl973 {
			yyb973 = yyj973 > l
		} else {
			yyb973 = r.CheckBreak()
		}
		if yyb973 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj973-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 {
		yym976 := z.EncBinary()
		_ = yym976
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep977 := !z.EncBinary()
			yy2arr977 := z.EncBasicHandle().StructToArray
			var yyq977 [1]bool
			_, _, _ = yysep977, yyq977, yy2arr977
			const yyr977 bool = false
			yyq977[0] = x.HTTP != nil
			var yynn977 int
			if yyr977 || yy2arr977 {
				r.EncodeArrayStart(1)
			} else {
				yynn977 = 0
				for _, b := range yyq977 {
					if b {
						yynn977++
					}
				}
				r.EncodeMapStart(yynn977)
				yynn977 = 0
			}
			if yyr977 || yy2arr977 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq977[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq977[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 yyr977 || yy2arr977 {
				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
	yym979 := z.DecBinary()
	_ = yym979
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct980 := r.ContainerType()
		if yyct980 == codecSelferValueTypeMap1234 {
			yyl980 := r.ReadMapStart()
			if yyl980 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl980, d)
			}
		} else if yyct980 == codecSelferValueTypeArray1234 {
			yyl980 := r.ReadArrayStart()
			if yyl980 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl980, 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 yys981Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys981Slc
	var yyhl981 bool = l >= 0
	for yyj981 := 0; ; yyj981++ {
		if yyhl981 {
			if yyj981 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys981Slc = r.DecodeBytes(yys981Slc, true, true)
		yys981 := string(yys981Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys981 {
		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, yys981)
		} // end switch yys981
	} // end for yyj981
	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 yyj983 int
	var yyb983 bool
	var yyhl983 bool = l >= 0
	yyj983++
	if yyhl983 {
		yyb983 = yyj983 > l
	} else {
		yyb983 = r.CheckBreak()
	}
	if yyb983 {
		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 {
		yyj983++
		if yyhl983 {
			yyb983 = yyj983 > l
		} else {
			yyb983 = r.CheckBreak()
		}
		if yyb983 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj983-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 {
		yym985 := z.EncBinary()
		_ = yym985
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep986 := !z.EncBinary()
			yy2arr986 := z.EncBasicHandle().StructToArray
			var yyq986 [1]bool
			_, _, _ = yysep986, yyq986, yy2arr986
			const yyr986 bool = false
			var yynn986 int
			if yyr986 || yy2arr986 {
				r.EncodeArrayStart(1)
			} else {
				yynn986 = 1
				for _, b := range yyq986 {
					if b {
						yynn986++
					}
				}
				r.EncodeMapStart(yynn986)
				yynn986 = 0
			}
			if yyr986 || yy2arr986 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym988 := z.EncBinary()
					_ = yym988
					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 {
					yym989 := z.EncBinary()
					_ = yym989
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr986 || yy2arr986 {
				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
	yym990 := z.DecBinary()
	_ = yym990
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct991 := r.ContainerType()
		if yyct991 == codecSelferValueTypeMap1234 {
			yyl991 := r.ReadMapStart()
			if yyl991 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl991, d)
			}
		} else if yyct991 == codecSelferValueTypeArray1234 {
			yyl991 := r.ReadArrayStart()
			if yyl991 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl991, 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 yys992Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys992Slc
	var yyhl992 bool = l >= 0
	for yyj992 := 0; ; yyj992++ {
		if yyhl992 {
			if yyj992 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys992Slc = r.DecodeBytes(yys992Slc, true, true)
		yys992 := string(yys992Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys992 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv993 := &x.Paths
				yym994 := z.DecBinary()
				_ = yym994
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv993), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys992)
		} // end switch yys992
	} // end for yyj992
	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 yyj995 int
	var yyb995 bool
	var yyhl995 bool = l >= 0
	yyj995++
	if yyhl995 {
		yyb995 = yyj995 > l
	} else {
		yyb995 = r.CheckBreak()
	}
	if yyb995 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv996 := &x.Paths
		yym997 := z.DecBinary()
		_ = yym997
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv996), d)
		}
	}
	for {
		yyj995++
		if yyhl995 {
			yyb995 = yyj995 > l
		} else {
			yyb995 = r.CheckBreak()
		}
		if yyb995 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj995-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 {
		yym998 := z.EncBinary()
		_ = yym998
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep999 := !z.EncBinary()
			yy2arr999 := z.EncBasicHandle().StructToArray
			var yyq999 [2]bool
			_, _, _ = yysep999, yyq999, yy2arr999
			const yyr999 bool = false
			yyq999[0] = x.Path != ""
			var yynn999 int
			if yyr999 || yy2arr999 {
				r.EncodeArrayStart(2)
			} else {
				yynn999 = 1
				for _, b := range yyq999 {
					if b {
						yynn999++
					}
				}
				r.EncodeMapStart(yynn999)
				yynn999 = 0
			}
			if yyr999 || yy2arr999 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq999[0] {
					yym1001 := z.EncBinary()
					_ = yym1001
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq999[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1002 := z.EncBinary()
					_ = yym1002
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr999 || yy2arr999 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1004 := &x.Backend
				yy1004.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1005 := &x.Backend
				yy1005.CodecEncodeSelf(e)
			}
			if yyr999 || yy2arr999 {
				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
	yym1006 := z.DecBinary()
	_ = yym1006
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1007 := r.ContainerType()
		if yyct1007 == codecSelferValueTypeMap1234 {
			yyl1007 := r.ReadMapStart()
			if yyl1007 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1007, d)
			}
		} else if yyct1007 == codecSelferValueTypeArray1234 {
			yyl1007 := r.ReadArrayStart()
			if yyl1007 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1007, 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 yys1008Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1008Slc
	var yyhl1008 bool = l >= 0
	for yyj1008 := 0; ; yyj1008++ {
		if yyhl1008 {
			if yyj1008 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1008Slc = r.DecodeBytes(yys1008Slc, true, true)
		yys1008 := string(yys1008Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1008 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv1010 := &x.Backend
				yyv1010.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1008)
		} // end switch yys1008
	} // end for yyj1008
	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 yyj1011 int
	var yyb1011 bool
	var yyhl1011 bool = l >= 0
	yyj1011++
	if yyhl1011 {
		yyb1011 = yyj1011 > l
	} else {
		yyb1011 = r.CheckBreak()
	}
	if yyb1011 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj1011++
	if yyhl1011 {
		yyb1011 = yyj1011 > l
	} else {
		yyb1011 = r.CheckBreak()
	}
	if yyb1011 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv1013 := &x.Backend
		yyv1013.CodecDecodeSelf(d)
	}
	for {
		yyj1011++
		if yyhl1011 {
			yyb1011 = yyj1011 > l
		} else {
			yyb1011 = r.CheckBreak()
		}
		if yyb1011 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1011-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 {
		yym1014 := z.EncBinary()
		_ = yym1014
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1015 := !z.EncBinary()
			yy2arr1015 := z.EncBasicHandle().StructToArray
			var yyq1015 [2]bool
			_, _, _ = yysep1015, yyq1015, yy2arr1015
			const yyr1015 bool = false
			var yynn1015 int
			if yyr1015 || yy2arr1015 {
				r.EncodeArrayStart(2)
			} else {
				yynn1015 = 2
				for _, b := range yyq1015 {
					if b {
						yynn1015++
					}
				}
				r.EncodeMapStart(yynn1015)
				yynn1015 = 0
			}
			if yyr1015 || yy2arr1015 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1017 := z.EncBinary()
				_ = yym1017
				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)
				yym1018 := z.EncBinary()
				_ = yym1018
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr1015 || yy2arr1015 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1020 := &x.ServicePort
				yym1021 := z.EncBinary()
				_ = yym1021
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1020) {
				} else if !yym1021 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1020)
				} else {
					z.EncFallback(yy1020)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1022 := &x.ServicePort
				yym1023 := z.EncBinary()
				_ = yym1023
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1022) {
				} else if !yym1023 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1022)
				} else {
					z.EncFallback(yy1022)
				}
			}
			if yyr1015 || yy2arr1015 {
				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
	yym1024 := z.DecBinary()
	_ = yym1024
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1025 := r.ContainerType()
		if yyct1025 == codecSelferValueTypeMap1234 {
			yyl1025 := r.ReadMapStart()
			if yyl1025 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1025, d)
			}
		} else if yyct1025 == codecSelferValueTypeArray1234 {
			yyl1025 := r.ReadArrayStart()
			if yyl1025 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1025, 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 yys1026Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1026Slc
	var yyhl1026 bool = l >= 0
	for yyj1026 := 0; ; yyj1026++ {
		if yyhl1026 {
			if yyj1026 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1026Slc = r.DecodeBytes(yys1026Slc, true, true)
		yys1026 := string(yys1026Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1026 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg6_intstr.IntOrString{}
			} else {
				yyv1028 := &x.ServicePort
				yym1029 := z.DecBinary()
				_ = yym1029
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1028) {
				} else if !yym1029 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1028)
				} else {
					z.DecFallback(yyv1028, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1026)
		} // end switch yys1026
	} // end for yyj1026
	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 yyj1030 int
	var yyb1030 bool
	var yyhl1030 bool = l >= 0
	yyj1030++
	if yyhl1030 {
		yyb1030 = yyj1030 > l
	} else {
		yyb1030 = r.CheckBreak()
	}
	if yyb1030 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj1030++
	if yyhl1030 {
		yyb1030 = yyj1030 > l
	} else {
		yyb1030 = r.CheckBreak()
	}
	if yyb1030 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg6_intstr.IntOrString{}
	} else {
		yyv1032 := &x.ServicePort
		yym1033 := z.DecBinary()
		_ = yym1033
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1032) {
		} else if !yym1033 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1032)
		} else {
			z.DecFallback(yyv1032, false)
		}
	}
	for {
		yyj1030++
		if yyhl1030 {
			yyb1030 = yyj1030 > l
		} else {
			yyb1030 = r.CheckBreak()
		}
		if yyb1030 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1030-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1034 := z.EncBinary()
	_ = yym1034
	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
	yym1035 := z.DecBinary()
	_ = yym1035
	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 {
		yym1036 := z.EncBinary()
		_ = yym1036
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1037 := !z.EncBinary()
			yy2arr1037 := z.EncBasicHandle().StructToArray
			var yyq1037 [2]bool
			_, _, _ = yysep1037, yyq1037, yy2arr1037
			const yyr1037 bool = false
			var yynn1037 int
			if yyr1037 || yy2arr1037 {
				r.EncodeArrayStart(2)
			} else {
				yynn1037 = 2
				for _, b := range yyq1037 {
					if b {
						yynn1037++
					}
				}
				r.EncodeMapStart(yynn1037)
				yynn1037 = 0
			}
			if yyr1037 || yy2arr1037 {
				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 yyr1037 || yy2arr1037 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1040 := z.EncBinary()
				_ = yym1040
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1041 := z.EncBinary()
				_ = yym1041
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yyr1037 || yy2arr1037 {
				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
	yym1042 := z.DecBinary()
	_ = yym1042
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1043 := r.ContainerType()
		if yyct1043 == codecSelferValueTypeMap1234 {
			yyl1043 := r.ReadMapStart()
			if yyl1043 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1043, d)
			}
		} else if yyct1043 == codecSelferValueTypeArray1234 {
			yyl1043 := r.ReadArrayStart()
			if yyl1043 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1043, 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 yys1044Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1044Slc
	var yyhl1044 bool = l >= 0
	for yyj1044 := 0; ; yyj1044++ {
		if yyhl1044 {
			if yyj1044 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1044Slc = r.DecodeBytes(yys1044Slc, true, true)
		yys1044 := string(yys1044Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1044 {
		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, yys1044)
		} // end switch yys1044
	} // end for yyj1044
	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 yyj1047 int
	var yyb1047 bool
	var yyhl1047 bool = l >= 0
	yyj1047++
	if yyhl1047 {
		yyb1047 = yyj1047 > l
	} else {
		yyb1047 = r.CheckBreak()
	}
	if yyb1047 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj1047++
	if yyhl1047 {
		yyb1047 = yyj1047 > l
	} else {
		yyb1047 = r.CheckBreak()
	}
	if yyb1047 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj1047++
		if yyhl1047 {
			yyb1047 = yyj1047 > l
		} else {
			yyb1047 = r.CheckBreak()
		}
		if yyb1047 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1047-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 {
		yym1050 := z.EncBinary()
		_ = yym1050
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1051 := !z.EncBinary()
			yy2arr1051 := z.EncBasicHandle().StructToArray
			var yyq1051 [3]bool
			_, _, _ = yysep1051, yyq1051, yy2arr1051
			const yyr1051 bool = false
			var yynn1051 int
			if yyr1051 || yy2arr1051 {
				r.EncodeArrayStart(3)
			} else {
				yynn1051 = 3
				for _, b := range yyq1051 {
					if b {
						yynn1051++
					}
				}
				r.EncodeMapStart(yynn1051)
				yynn1051 = 0
			}
			if yyr1051 || yy2arr1051 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1053 := z.EncBinary()
				_ = yym1053
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1054 := z.EncBinary()
				_ = yym1054
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1051 || yy2arr1051 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1056 := z.EncBinary()
				_ = yym1056
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1057 := z.EncBinary()
				_ = yym1057
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1051 || yy2arr1051 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1059 := z.EncBinary()
					_ = yym1059
					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 {
					yym1060 := z.EncBinary()
					_ = yym1060
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yyr1051 || yy2arr1051 {
				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
	yym1061 := z.DecBinary()
	_ = yym1061
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1062 := r.ContainerType()
		if yyct1062 == codecSelferValueTypeMap1234 {
			yyl1062 := r.ReadMapStart()
			if yyl1062 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1062, d)
			}
		} else if yyct1062 == codecSelferValueTypeArray1234 {
			yyl1062 := r.ReadArrayStart()
			if yyl1062 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1062, 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 yys1063Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1063Slc
	var yyhl1063 bool = l >= 0
	for yyj1063 := 0; ; yyj1063++ {
		if yyhl1063 {
			if yyj1063 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1063Slc = r.DecodeBytes(yys1063Slc, true, true)
		yys1063 := string(yys1063Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1063 {
		case "minNodes":
			if r.TryDecodeAsNil() {
				x.MinNodes = 0
			} else {
				x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "maxNodes":
			if r.TryDecodeAsNil() {
				x.MaxNodes = 0
			} else {
				x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "target":
			if r.TryDecodeAsNil() {
				x.TargetUtilization = nil
			} else {
				yyv1066 := &x.TargetUtilization
				yym1067 := z.DecBinary()
				_ = yym1067
				if false {
				} else {
					h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1066), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1063)
		} // end switch yys1063
	} // end for yyj1063
	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 yyj1068 int
	var yyb1068 bool
	var yyhl1068 bool = l >= 0
	yyj1068++
	if yyhl1068 {
		yyb1068 = yyj1068 > l
	} else {
		yyb1068 = r.CheckBreak()
	}
	if yyb1068 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1068++
	if yyhl1068 {
		yyb1068 = yyj1068 > l
	} else {
		yyb1068 = r.CheckBreak()
	}
	if yyb1068 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1068++
	if yyhl1068 {
		yyb1068 = yyj1068 > l
	} else {
		yyb1068 = r.CheckBreak()
	}
	if yyb1068 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1071 := &x.TargetUtilization
		yym1072 := z.DecBinary()
		_ = yym1072
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1071), d)
		}
	}
	for {
		yyj1068++
		if yyhl1068 {
			yyb1068 = yyj1068 > l
		} else {
			yyb1068 = r.CheckBreak()
		}
		if yyb1068 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1068-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 {
		yym1073 := z.EncBinary()
		_ = yym1073
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1074 := !z.EncBinary()
			yy2arr1074 := z.EncBasicHandle().StructToArray
			var yyq1074 [4]bool
			_, _, _ = yysep1074, yyq1074, yy2arr1074
			const yyr1074 bool = false
			yyq1074[0] = x.Kind != ""
			yyq1074[1] = x.APIVersion != ""
			yyq1074[2] = true
			yyq1074[3] = true
			var yynn1074 int
			if yyr1074 || yy2arr1074 {
				r.EncodeArrayStart(4)
			} else {
				yynn1074 = 0
				for _, b := range yyq1074 {
					if b {
						yynn1074++
					}
				}
				r.EncodeMapStart(yynn1074)
				yynn1074 = 0
			}
			if yyr1074 || yy2arr1074 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1074[0] {
					yym1076 := z.EncBinary()
					_ = yym1076
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1074[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1077 := z.EncBinary()
					_ = yym1077
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1074 || yy2arr1074 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1074[1] {
					yym1079 := z.EncBinary()
					_ = yym1079
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1074[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1080 := z.EncBinary()
					_ = yym1080
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1074 || yy2arr1074 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1074[2] {
					yy1082 := &x.ObjectMeta
					yy1082.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1074[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1083 := &x.ObjectMeta
					yy1083.CodecEncodeSelf(e)
				}
			}
			if yyr1074 || yy2arr1074 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1074[3] {
					yy1085 := &x.Spec
					yy1085.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1074[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1086 := &x.Spec
					yy1086.CodecEncodeSelf(e)
				}
			}
			if yyr1074 || yy2arr1074 {
				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
	yym1087 := z.DecBinary()
	_ = yym1087
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1088 := r.ContainerType()
		if yyct1088 == codecSelferValueTypeMap1234 {
			yyl1088 := r.ReadMapStart()
			if yyl1088 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1088, d)
			}
		} else if yyct1088 == codecSelferValueTypeArray1234 {
			yyl1088 := r.ReadArrayStart()
			if yyl1088 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1088, 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 yys1089Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1089Slc
	var yyhl1089 bool = l >= 0
	for yyj1089 := 0; ; yyj1089++ {
		if yyhl1089 {
			if yyj1089 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1089Slc = r.DecodeBytes(yys1089Slc, true, true)
		yys1089 := string(yys1089Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1089 {
		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_api.ObjectMeta{}
			} else {
				yyv1092 := &x.ObjectMeta
				yyv1092.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ClusterAutoscalerSpec{}
			} else {
				yyv1093 := &x.Spec
				yyv1093.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1089)
		} // end switch yys1089
	} // end for yyj1089
	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 yyj1094 int
	var yyb1094 bool
	var yyhl1094 bool = l >= 0
	yyj1094++
	if yyhl1094 {
		yyb1094 = yyj1094 > l
	} else {
		yyb1094 = r.CheckBreak()
	}
	if yyb1094 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1094++
	if yyhl1094 {
		yyb1094 = yyj1094 > l
	} else {
		yyb1094 = r.CheckBreak()
	}
	if yyb1094 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1094++
	if yyhl1094 {
		yyb1094 = yyj1094 > l
	} else {
		yyb1094 = r.CheckBreak()
	}
	if yyb1094 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1097 := &x.ObjectMeta
		yyv1097.CodecDecodeSelf(d)
	}
	yyj1094++
	if yyhl1094 {
		yyb1094 = yyj1094 > l
	} else {
		yyb1094 = r.CheckBreak()
	}
	if yyb1094 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1098 := &x.Spec
		yyv1098.CodecDecodeSelf(d)
	}
	for {
		yyj1094++
		if yyhl1094 {
			yyb1094 = yyj1094 > l
		} else {
			yyb1094 = r.CheckBreak()
		}
		if yyb1094 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1094-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 {
		yym1099 := z.EncBinary()
		_ = yym1099
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1100 := !z.EncBinary()
			yy2arr1100 := z.EncBasicHandle().StructToArray
			var yyq1100 [4]bool
			_, _, _ = yysep1100, yyq1100, yy2arr1100
			const yyr1100 bool = false
			yyq1100[0] = x.Kind != ""
			yyq1100[1] = x.APIVersion != ""
			yyq1100[2] = true
			var yynn1100 int
			if yyr1100 || yy2arr1100 {
				r.EncodeArrayStart(4)
			} else {
				yynn1100 = 1
				for _, b := range yyq1100 {
					if b {
						yynn1100++
					}
				}
				r.EncodeMapStart(yynn1100)
				yynn1100 = 0
			}
			if yyr1100 || yy2arr1100 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1100[0] {
					yym1102 := z.EncBinary()
					_ = yym1102
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1100[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1103 := z.EncBinary()
					_ = yym1103
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1100 || yy2arr1100 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1100[1] {
					yym1105 := z.EncBinary()
					_ = yym1105
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1100[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1106 := z.EncBinary()
					_ = yym1106
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1100 || yy2arr1100 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1100[2] {
					yy1108 := &x.ListMeta
					yym1109 := z.EncBinary()
					_ = yym1109
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1108) {
					} else {
						z.EncFallback(yy1108)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1100[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1110 := &x.ListMeta
					yym1111 := z.EncBinary()
					_ = yym1111
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1110) {
					} else {
						z.EncFallback(yy1110)
					}
				}
			}
			if yyr1100 || yy2arr1100 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1113 := z.EncBinary()
					_ = yym1113
					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 {
					yym1114 := z.EncBinary()
					_ = yym1114
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr1100 || yy2arr1100 {
				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
	yym1115 := z.DecBinary()
	_ = yym1115
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1116 := r.ContainerType()
		if yyct1116 == codecSelferValueTypeMap1234 {
			yyl1116 := r.ReadMapStart()
			if yyl1116 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1116, d)
			}
		} else if yyct1116 == codecSelferValueTypeArray1234 {
			yyl1116 := r.ReadArrayStart()
			if yyl1116 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1116, 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 yys1117Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1117Slc
	var yyhl1117 bool = l >= 0
	for yyj1117 := 0; ; yyj1117++ {
		if yyhl1117 {
			if yyj1117 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1117Slc = r.DecodeBytes(yys1117Slc, true, true)
		yys1117 := string(yys1117Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1117 {
		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 {
				yyv1120 := &x.ListMeta
				yym1121 := z.DecBinary()
				_ = yym1121
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1120) {
				} else {
					z.DecFallback(yyv1120, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1122 := &x.Items
				yym1123 := z.DecBinary()
				_ = yym1123
				if false {
				} else {
					h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1122), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1117)
		} // end switch yys1117
	} // end for yyj1117
	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 yyj1124 int
	var yyb1124 bool
	var yyhl1124 bool = l >= 0
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1127 := &x.ListMeta
		yym1128 := z.DecBinary()
		_ = yym1128
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1127) {
		} else {
			z.DecFallback(yyv1127, false)
		}
	}
	yyj1124++
	if yyhl1124 {
		yyb1124 = yyj1124 > l
	} else {
		yyb1124 = r.CheckBreak()
	}
	if yyb1124 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1129 := &x.Items
		yym1130 := z.DecBinary()
		_ = yym1130
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1129), d)
		}
	}
	for {
		yyj1124++
		if yyhl1124 {
			yyb1124 = yyj1124 > l
		} else {
			yyb1124 = r.CheckBreak()
		}
		if yyb1124 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1124-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 {
		yym1131 := z.EncBinary()
		_ = yym1131
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1132 := !z.EncBinary()
			yy2arr1132 := z.EncBasicHandle().StructToArray
			var yyq1132 [2]bool
			_, _, _ = yysep1132, yyq1132, yy2arr1132
			const yyr1132 bool = false
			yyq1132[0] = len(x.MatchLabels) != 0
			yyq1132[1] = len(x.MatchExpressions) != 0
			var yynn1132 int
			if yyr1132 || yy2arr1132 {
				r.EncodeArrayStart(2)
			} else {
				yynn1132 = 0
				for _, b := range yyq1132 {
					if b {
						yynn1132++
					}
				}
				r.EncodeMapStart(yynn1132)
				yynn1132 = 0
			}
			if yyr1132 || yy2arr1132 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1132[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1134 := z.EncBinary()
						_ = yym1134
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1132[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1135 := z.EncBinary()
						_ = yym1135
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1132 || yy2arr1132 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1132[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1137 := z.EncBinary()
						_ = yym1137
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1132[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1138 := z.EncBinary()
						_ = yym1138
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yyr1132 || yy2arr1132 {
				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
	yym1139 := z.DecBinary()
	_ = yym1139
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1140 := r.ContainerType()
		if yyct1140 == codecSelferValueTypeMap1234 {
			yyl1140 := r.ReadMapStart()
			if yyl1140 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1140, d)
			}
		} else if yyct1140 == codecSelferValueTypeArray1234 {
			yyl1140 := r.ReadArrayStart()
			if yyl1140 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1140, 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 yys1141Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1141Slc
	var yyhl1141 bool = l >= 0
	for yyj1141 := 0; ; yyj1141++ {
		if yyhl1141 {
			if yyj1141 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1141Slc = r.DecodeBytes(yys1141Slc, true, true)
		yys1141 := string(yys1141Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1141 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1142 := &x.MatchLabels
				yym1143 := z.DecBinary()
				_ = yym1143
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1142, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1144 := &x.MatchExpressions
				yym1145 := z.DecBinary()
				_ = yym1145
				if false {
				} else {
					h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1144), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1141)
		} // end switch yys1141
	} // end for yyj1141
	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 yyj1146 int
	var yyb1146 bool
	var yyhl1146 bool = l >= 0
	yyj1146++
	if yyhl1146 {
		yyb1146 = yyj1146 > l
	} else {
		yyb1146 = r.CheckBreak()
	}
	if yyb1146 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1147 := &x.MatchLabels
		yym1148 := z.DecBinary()
		_ = yym1148
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1147, false, d)
		}
	}
	yyj1146++
	if yyhl1146 {
		yyb1146 = yyj1146 > l
	} else {
		yyb1146 = r.CheckBreak()
	}
	if yyb1146 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1149 := &x.MatchExpressions
		yym1150 := z.DecBinary()
		_ = yym1150
		if false {
		} else {
			h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1149), d)
		}
	}
	for {
		yyj1146++
		if yyhl1146 {
			yyb1146 = yyj1146 > l
		} else {
			yyb1146 = r.CheckBreak()
		}
		if yyb1146 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1146-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 {
		yym1151 := z.EncBinary()
		_ = yym1151
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1152 := !z.EncBinary()
			yy2arr1152 := z.EncBasicHandle().StructToArray
			var yyq1152 [3]bool
			_, _, _ = yysep1152, yyq1152, yy2arr1152
			const yyr1152 bool = false
			yyq1152[2] = len(x.Values) != 0
			var yynn1152 int
			if yyr1152 || yy2arr1152 {
				r.EncodeArrayStart(3)
			} else {
				yynn1152 = 2
				for _, b := range yyq1152 {
					if b {
						yynn1152++
					}
				}
				r.EncodeMapStart(yynn1152)
				yynn1152 = 0
			}
			if yyr1152 || yy2arr1152 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1154 := z.EncBinary()
				_ = yym1154
				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)
				yym1155 := z.EncBinary()
				_ = yym1155
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1152 || yy2arr1152 {
				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 yyr1152 || yy2arr1152 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1152[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1158 := z.EncBinary()
						_ = yym1158
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1152[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1159 := z.EncBinary()
						_ = yym1159
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yyr1152 || yy2arr1152 {
				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
	yym1160 := z.DecBinary()
	_ = yym1160
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1161 := r.ContainerType()
		if yyct1161 == codecSelferValueTypeMap1234 {
			yyl1161 := r.ReadMapStart()
			if yyl1161 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1161, d)
			}
		} else if yyct1161 == codecSelferValueTypeArray1234 {
			yyl1161 := r.ReadArrayStart()
			if yyl1161 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1161, 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 yys1162Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1162Slc
	var yyhl1162 bool = l >= 0
	for yyj1162 := 0; ; yyj1162++ {
		if yyhl1162 {
			if yyj1162 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1162Slc = r.DecodeBytes(yys1162Slc, true, true)
		yys1162 := string(yys1162Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1162 {
		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 {
				yyv1165 := &x.Values
				yym1166 := z.DecBinary()
				_ = yym1166
				if false {
				} else {
					z.F.DecSliceStringX(yyv1165, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1162)
		} // end switch yys1162
	} // end for yyj1162
	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 yyj1167 int
	var yyb1167 bool
	var yyhl1167 bool = l >= 0
	yyj1167++
	if yyhl1167 {
		yyb1167 = yyj1167 > l
	} else {
		yyb1167 = r.CheckBreak()
	}
	if yyb1167 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1167++
	if yyhl1167 {
		yyb1167 = yyj1167 > l
	} else {
		yyb1167 = r.CheckBreak()
	}
	if yyb1167 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = LabelSelectorOperator(r.DecodeString())
	}
	yyj1167++
	if yyhl1167 {
		yyb1167 = yyj1167 > l
	} else {
		yyb1167 = r.CheckBreak()
	}
	if yyb1167 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1170 := &x.Values
		yym1171 := z.DecBinary()
		_ = yym1171
		if false {
		} else {
			z.F.DecSliceStringX(yyv1170, false, d)
		}
	}
	for {
		yyj1167++
		if yyhl1167 {
			yyb1167 = yyj1167 > l
		} else {
			yyb1167 = r.CheckBreak()
		}
		if yyb1167 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1167-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1172 := z.EncBinary()
	_ = yym1172
	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
	yym1173 := z.DecBinary()
	_ = yym1173
	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 {
		yym1174 := z.EncBinary()
		_ = yym1174
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1175 := !z.EncBinary()
			yy2arr1175 := z.EncBasicHandle().StructToArray
			var yyq1175 [4]bool
			_, _, _ = yysep1175, yyq1175, yy2arr1175
			const yyr1175 bool = false
			yyq1175[0] = x.Kind != ""
			yyq1175[1] = x.APIVersion != ""
			yyq1175[2] = true
			yyq1175[3] = len(x.Data) != 0
			var yynn1175 int
			if yyr1175 || yy2arr1175 {
				r.EncodeArrayStart(4)
			} else {
				yynn1175 = 0
				for _, b := range yyq1175 {
					if b {
						yynn1175++
					}
				}
				r.EncodeMapStart(yynn1175)
				yynn1175 = 0
			}
			if yyr1175 || yy2arr1175 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1175[0] {
					yym1177 := z.EncBinary()
					_ = yym1177
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1175[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1178 := z.EncBinary()
					_ = yym1178
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1175 || yy2arr1175 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1175[1] {
					yym1180 := z.EncBinary()
					_ = yym1180
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1175[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1181 := z.EncBinary()
					_ = yym1181
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1175 || yy2arr1175 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1175[2] {
					yy1183 := &x.ObjectMeta
					yy1183.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1175[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1184 := &x.ObjectMeta
					yy1184.CodecEncodeSelf(e)
				}
			}
			if yyr1175 || yy2arr1175 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1175[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym1186 := z.EncBinary()
						_ = yym1186
						if false {
						} else {
							z.F.EncMapStringStringV(x.Data, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1175[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym1187 := z.EncBinary()
						_ = yym1187
						if false {
						} else {
							z.F.EncMapStringStringV(x.Data, false, e)
						}
					}
				}
			}
			if yyr1175 || yy2arr1175 {
				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
	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 *ConfigMap) 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 "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv1193 := &x.ObjectMeta
				yyv1193.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv1194 := &x.Data
				yym1195 := z.DecBinary()
				_ = yym1195
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1194, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1190)
		} // end switch yys1190
	} // end for yyj1190
	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 yyj1196 int
	var yyb1196 bool
	var yyhl1196 bool = l >= 0
	yyj1196++
	if yyhl1196 {
		yyb1196 = yyj1196 > l
	} else {
		yyb1196 = r.CheckBreak()
	}
	if yyb1196 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1196++
	if yyhl1196 {
		yyb1196 = yyj1196 > l
	} else {
		yyb1196 = r.CheckBreak()
	}
	if yyb1196 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1196++
	if yyhl1196 {
		yyb1196 = yyj1196 > l
	} else {
		yyb1196 = r.CheckBreak()
	}
	if yyb1196 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1199 := &x.ObjectMeta
		yyv1199.CodecDecodeSelf(d)
	}
	yyj1196++
	if yyhl1196 {
		yyb1196 = yyj1196 > l
	} else {
		yyb1196 = r.CheckBreak()
	}
	if yyb1196 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv1200 := &x.Data
		yym1201 := z.DecBinary()
		_ = yym1201
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1200, false, d)
		}
	}
	for {
		yyj1196++
		if yyhl1196 {
			yyb1196 = yyj1196 > l
		} else {
			yyb1196 = r.CheckBreak()
		}
		if yyb1196 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1196-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 {
		yym1202 := z.EncBinary()
		_ = yym1202
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1203 := !z.EncBinary()
			yy2arr1203 := z.EncBasicHandle().StructToArray
			var yyq1203 [4]bool
			_, _, _ = yysep1203, yyq1203, yy2arr1203
			const yyr1203 bool = false
			yyq1203[0] = x.Kind != ""
			yyq1203[1] = x.APIVersion != ""
			yyq1203[2] = true
			yyq1203[3] = len(x.Items) != 0
			var yynn1203 int
			if yyr1203 || yy2arr1203 {
				r.EncodeArrayStart(4)
			} else {
				yynn1203 = 0
				for _, b := range yyq1203 {
					if b {
						yynn1203++
					}
				}
				r.EncodeMapStart(yynn1203)
				yynn1203 = 0
			}
			if yyr1203 || yy2arr1203 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1203[0] {
					yym1205 := z.EncBinary()
					_ = yym1205
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1203[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1206 := z.EncBinary()
					_ = yym1206
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1203 || yy2arr1203 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1203[1] {
					yym1208 := z.EncBinary()
					_ = yym1208
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1203[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1209 := z.EncBinary()
					_ = yym1209
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1203 || yy2arr1203 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1203[2] {
					yy1211 := &x.ListMeta
					yym1212 := z.EncBinary()
					_ = yym1212
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1211) {
					} else {
						z.EncFallback(yy1211)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1203[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1213 := &x.ListMeta
					yym1214 := z.EncBinary()
					_ = yym1214
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1213) {
					} else {
						z.EncFallback(yy1213)
					}
				}
			}
			if yyr1203 || yy2arr1203 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1203[3] {
					if x.Items == nil {
						r.EncodeNil()
					} else {
						yym1216 := z.EncBinary()
						_ = yym1216
						if false {
						} else {
							h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1203[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("items"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Items == nil {
						r.EncodeNil()
					} else {
						yym1217 := z.EncBinary()
						_ = yym1217
						if false {
						} else {
							h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
						}
					}
				}
			}
			if yyr1203 || yy2arr1203 {
				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
	yym1218 := z.DecBinary()
	_ = yym1218
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1219 := r.ContainerType()
		if yyct1219 == codecSelferValueTypeMap1234 {
			yyl1219 := r.ReadMapStart()
			if yyl1219 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1219, d)
			}
		} else if yyct1219 == codecSelferValueTypeArray1234 {
			yyl1219 := r.ReadArrayStart()
			if yyl1219 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1219, 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 yys1220Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1220Slc
	var yyhl1220 bool = l >= 0
	for yyj1220 := 0; ; yyj1220++ {
		if yyhl1220 {
			if yyj1220 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1220Slc = r.DecodeBytes(yys1220Slc, true, true)
		yys1220 := string(yys1220Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1220 {
		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 {
				yyv1223 := &x.ListMeta
				yym1224 := z.DecBinary()
				_ = yym1224
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1223) {
				} else {
					z.DecFallback(yyv1223, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1225 := &x.Items
				yym1226 := z.DecBinary()
				_ = yym1226
				if false {
				} else {
					h.decSliceConfigMap((*[]ConfigMap)(yyv1225), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1220)
		} // end switch yys1220
	} // end for yyj1220
	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 yyj1227 int
	var yyb1227 bool
	var yyhl1227 bool = l >= 0
	yyj1227++
	if yyhl1227 {
		yyb1227 = yyj1227 > l
	} else {
		yyb1227 = r.CheckBreak()
	}
	if yyb1227 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1227++
	if yyhl1227 {
		yyb1227 = yyj1227 > l
	} else {
		yyb1227 = r.CheckBreak()
	}
	if yyb1227 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1227++
	if yyhl1227 {
		yyb1227 = yyj1227 > l
	} else {
		yyb1227 = r.CheckBreak()
	}
	if yyb1227 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1230 := &x.ListMeta
		yym1231 := z.DecBinary()
		_ = yym1231
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1230) {
		} else {
			z.DecFallback(yyv1230, false)
		}
	}
	yyj1227++
	if yyhl1227 {
		yyb1227 = yyj1227 > l
	} else {
		yyb1227 = r.CheckBreak()
	}
	if yyb1227 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1232 := &x.Items
		yym1233 := z.DecBinary()
		_ = yym1233
		if false {
		} else {
			h.decSliceConfigMap((*[]ConfigMap)(yyv1232), d)
		}
	}
	for {
		yyj1227++
		if yyhl1227 {
			yyb1227 = yyj1227 > l
		} else {
			yyb1227 = r.CheckBreak()
		}
		if yyb1227 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1227-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 {
		yym1234 := z.EncBinary()
		_ = yym1234
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1235 := !z.EncBinary()
			yy2arr1235 := z.EncBasicHandle().StructToArray
			var yyq1235 [5]bool
			_, _, _ = yysep1235, yyq1235, yy2arr1235
			const yyr1235 bool = false
			yyq1235[0] = x.Kind != ""
			yyq1235[1] = x.APIVersion != ""
			yyq1235[2] = true
			yyq1235[3] = true
			yyq1235[4] = true
			var yynn1235 int
			if yyr1235 || yy2arr1235 {
				r.EncodeArrayStart(5)
			} else {
				yynn1235 = 0
				for _, b := range yyq1235 {
					if b {
						yynn1235++
					}
				}
				r.EncodeMapStart(yynn1235)
				yynn1235 = 0
			}
			if yyr1235 || yy2arr1235 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1235[0] {
					yym1237 := z.EncBinary()
					_ = yym1237
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1235[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1238 := z.EncBinary()
					_ = yym1238
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1235 || yy2arr1235 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1235[1] {
					yym1240 := z.EncBinary()
					_ = yym1240
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1235[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1241 := z.EncBinary()
					_ = yym1241
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1235 || yy2arr1235 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1235[2] {
					yy1243 := &x.ObjectMeta
					yy1243.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1235[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1244 := &x.ObjectMeta
					yy1244.CodecEncodeSelf(e)
				}
			}
			if yyr1235 || yy2arr1235 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1235[3] {
					yy1246 := &x.Spec
					yy1246.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1235[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1247 := &x.Spec
					yy1247.CodecEncodeSelf(e)
				}
			}
			if yyr1235 || yy2arr1235 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1235[4] {
					yy1249 := &x.Status
					yy1249.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1235[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1250 := &x.Status
					yy1250.CodecEncodeSelf(e)
				}
			}
			if yyr1235 || yy2arr1235 {
				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
	yym1251 := z.DecBinary()
	_ = yym1251
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1252 := r.ContainerType()
		if yyct1252 == codecSelferValueTypeMap1234 {
			yyl1252 := r.ReadMapStart()
			if yyl1252 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1252, d)
			}
		} else if yyct1252 == codecSelferValueTypeArray1234 {
			yyl1252 := r.ReadArrayStart()
			if yyl1252 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1252, 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 yys1253Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1253Slc
	var yyhl1253 bool = l >= 0
	for yyj1253 := 0; ; yyj1253++ {
		if yyhl1253 {
			if yyj1253 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1253Slc = r.DecodeBytes(yys1253Slc, true, true)
		yys1253 := string(yys1253Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1253 {
		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_api.ObjectMeta{}
			} else {
				yyv1256 := &x.ObjectMeta
				yyv1256.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv1257 := &x.Spec
				yyv1257.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv1258 := &x.Status
				yyv1258.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1253)
		} // end switch yys1253
	} // end for yyj1253
	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 yyj1259 int
	var yyb1259 bool
	var yyhl1259 bool = l >= 0
	yyj1259++
	if yyhl1259 {
		yyb1259 = yyj1259 > l
	} else {
		yyb1259 = r.CheckBreak()
	}
	if yyb1259 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1259++
	if yyhl1259 {
		yyb1259 = yyj1259 > l
	} else {
		yyb1259 = r.CheckBreak()
	}
	if yyb1259 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1259++
	if yyhl1259 {
		yyb1259 = yyj1259 > l
	} else {
		yyb1259 = r.CheckBreak()
	}
	if yyb1259 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1262 := &x.ObjectMeta
		yyv1262.CodecDecodeSelf(d)
	}
	yyj1259++
	if yyhl1259 {
		yyb1259 = yyj1259 > l
	} else {
		yyb1259 = r.CheckBreak()
	}
	if yyb1259 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv1263 := &x.Spec
		yyv1263.CodecDecodeSelf(d)
	}
	yyj1259++
	if yyhl1259 {
		yyb1259 = yyj1259 > l
	} else {
		yyb1259 = r.CheckBreak()
	}
	if yyb1259 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv1264 := &x.Status
		yyv1264.CodecDecodeSelf(d)
	}
	for {
		yyj1259++
		if yyhl1259 {
			yyb1259 = yyj1259 > l
		} else {
			yyb1259 = r.CheckBreak()
		}
		if yyb1259 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1259-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 {
		yym1265 := z.EncBinary()
		_ = yym1265
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1266 := !z.EncBinary()
			yy2arr1266 := z.EncBasicHandle().StructToArray
			var yyq1266 [4]bool
			_, _, _ = yysep1266, yyq1266, yy2arr1266
			const yyr1266 bool = false
			yyq1266[0] = x.Kind != ""
			yyq1266[1] = x.APIVersion != ""
			yyq1266[2] = true
			var yynn1266 int
			if yyr1266 || yy2arr1266 {
				r.EncodeArrayStart(4)
			} else {
				yynn1266 = 1
				for _, b := range yyq1266 {
					if b {
						yynn1266++
					}
				}
				r.EncodeMapStart(yynn1266)
				yynn1266 = 0
			}
			if yyr1266 || yy2arr1266 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1266[0] {
					yym1268 := z.EncBinary()
					_ = yym1268
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1266[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1269 := z.EncBinary()
					_ = yym1269
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1266 || yy2arr1266 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1266[1] {
					yym1271 := z.EncBinary()
					_ = yym1271
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1266[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1272 := z.EncBinary()
					_ = yym1272
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1266 || yy2arr1266 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1266[2] {
					yy1274 := &x.ListMeta
					yym1275 := z.EncBinary()
					_ = yym1275
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1274) {
					} else {
						z.EncFallback(yy1274)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1266[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1276 := &x.ListMeta
					yym1277 := z.EncBinary()
					_ = yym1277
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1276) {
					} else {
						z.EncFallback(yy1276)
					}
				}
			}
			if yyr1266 || yy2arr1266 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1279 := z.EncBinary()
					_ = yym1279
					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 {
					yym1280 := z.EncBinary()
					_ = yym1280
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr1266 || yy2arr1266 {
				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
	yym1281 := z.DecBinary()
	_ = yym1281
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1282 := r.ContainerType()
		if yyct1282 == codecSelferValueTypeMap1234 {
			yyl1282 := r.ReadMapStart()
			if yyl1282 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1282, d)
			}
		} else if yyct1282 == codecSelferValueTypeArray1234 {
			yyl1282 := r.ReadArrayStart()
			if yyl1282 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1282, 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 yys1283Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1283Slc
	var yyhl1283 bool = l >= 0
	for yyj1283 := 0; ; yyj1283++ {
		if yyhl1283 {
			if yyj1283 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1283Slc = r.DecodeBytes(yys1283Slc, true, true)
		yys1283 := string(yys1283Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1283 {
		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 {
				yyv1286 := &x.ListMeta
				yym1287 := z.DecBinary()
				_ = yym1287
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1286) {
				} else {
					z.DecFallback(yyv1286, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1288 := &x.Items
				yym1289 := z.DecBinary()
				_ = yym1289
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv1288), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1283)
		} // end switch yys1283
	} // end for yyj1283
	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 yyj1290 int
	var yyb1290 bool
	var yyhl1290 bool = l >= 0
	yyj1290++
	if yyhl1290 {
		yyb1290 = yyj1290 > l
	} else {
		yyb1290 = r.CheckBreak()
	}
	if yyb1290 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1290++
	if yyhl1290 {
		yyb1290 = yyj1290 > l
	} else {
		yyb1290 = r.CheckBreak()
	}
	if yyb1290 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1290++
	if yyhl1290 {
		yyb1290 = yyj1290 > l
	} else {
		yyb1290 = r.CheckBreak()
	}
	if yyb1290 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1293 := &x.ListMeta
		yym1294 := z.DecBinary()
		_ = yym1294
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1293) {
		} else {
			z.DecFallback(yyv1293, false)
		}
	}
	yyj1290++
	if yyhl1290 {
		yyb1290 = yyj1290 > l
	} else {
		yyb1290 = r.CheckBreak()
	}
	if yyb1290 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1295 := &x.Items
		yym1296 := z.DecBinary()
		_ = yym1296
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv1295), d)
		}
	}
	for {
		yyj1290++
		if yyhl1290 {
			yyb1290 = yyj1290 > l
		} else {
			yyb1290 = r.CheckBreak()
		}
		if yyb1290 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1290-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 {
		yym1297 := z.EncBinary()
		_ = yym1297
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1298 := !z.EncBinary()
			yy2arr1298 := z.EncBasicHandle().StructToArray
			var yyq1298 [3]bool
			_, _, _ = yysep1298, yyq1298, yy2arr1298
			const yyr1298 bool = false
			yyq1298[1] = x.Selector != nil
			yyq1298[2] = x.Template != nil
			var yynn1298 int
			if yyr1298 || yy2arr1298 {
				r.EncodeArrayStart(3)
			} else {
				yynn1298 = 1
				for _, b := range yyq1298 {
					if b {
						yynn1298++
					}
				}
				r.EncodeMapStart(yynn1298)
				yynn1298 = 0
			}
			if yyr1298 || yy2arr1298 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1300 := z.EncBinary()
				_ = yym1300
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1301 := z.EncBinary()
				_ = yym1301
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1298 || yy2arr1298 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1298[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1298[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 yyr1298 || yy2arr1298 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1298[2] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1298[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 yyr1298 || yy2arr1298 {
				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
	yym1304 := z.DecBinary()
	_ = yym1304
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1305 := r.ContainerType()
		if yyct1305 == codecSelferValueTypeMap1234 {
			yyl1305 := r.ReadMapStart()
			if yyl1305 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1305, d)
			}
		} else if yyct1305 == codecSelferValueTypeArray1234 {
			yyl1305 := r.ReadArrayStart()
			if yyl1305 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1305, 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 yys1306Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1306Slc
	var yyhl1306 bool = l >= 0
	for yyj1306 := 0; ; yyj1306++ {
		if yyhl1306 {
			if yyj1306 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1306Slc = r.DecodeBytes(yys1306Slc, true, true)
		yys1306 := string(yys1306Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1306 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		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_api.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1306)
		} // end switch yys1306
	} // end for yyj1306
	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 yyj1310 int
	var yyb1310 bool
	var yyhl1310 bool = l >= 0
	yyj1310++
	if yyhl1310 {
		yyb1310 = yyj1310 > l
	} else {
		yyb1310 = r.CheckBreak()
	}
	if yyb1310 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1310++
	if yyhl1310 {
		yyb1310 = yyj1310 > l
	} else {
		yyb1310 = r.CheckBreak()
	}
	if yyb1310 {
		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)
	}
	yyj1310++
	if yyhl1310 {
		yyb1310 = yyj1310 > l
	} else {
		yyb1310 = r.CheckBreak()
	}
	if yyb1310 {
		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_api.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj1310++
		if yyhl1310 {
			yyb1310 = yyj1310 > l
		} else {
			yyb1310 = r.CheckBreak()
		}
		if yyb1310 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1310-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 {
		yym1314 := z.EncBinary()
		_ = yym1314
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1315 := !z.EncBinary()
			yy2arr1315 := z.EncBasicHandle().StructToArray
			var yyq1315 [2]bool
			_, _, _ = yysep1315, yyq1315, yy2arr1315
			const yyr1315 bool = false
			yyq1315[1] = x.ObservedGeneration != 0
			var yynn1315 int
			if yyr1315 || yy2arr1315 {
				r.EncodeArrayStart(2)
			} else {
				yynn1315 = 1
				for _, b := range yyq1315 {
					if b {
						yynn1315++
					}
				}
				r.EncodeMapStart(yynn1315)
				yynn1315 = 0
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1317 := z.EncBinary()
				_ = yym1317
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1318 := z.EncBinary()
				_ = yym1318
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[1] {
					yym1320 := z.EncBinary()
					_ = yym1320
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1315[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1321 := z.EncBinary()
					_ = yym1321
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				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
	yym1322 := z.DecBinary()
	_ = yym1322
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1323 := r.ContainerType()
		if yyct1323 == codecSelferValueTypeMap1234 {
			yyl1323 := r.ReadMapStart()
			if yyl1323 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1323, d)
			}
		} else if yyct1323 == codecSelferValueTypeArray1234 {
			yyl1323 := r.ReadArrayStart()
			if yyl1323 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1323, 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 yys1324Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1324Slc
	var yyhl1324 bool = l >= 0
	for yyj1324 := 0; ; yyj1324++ {
		if yyhl1324 {
			if yyj1324 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1324Slc = r.DecodeBytes(yys1324Slc, true, true)
		yys1324 := string(yys1324Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1324 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1324)
		} // end switch yys1324
	} // end for yyj1324
	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 yyj1327 int
	var yyb1327 bool
	var yyhl1327 bool = l >= 0
	yyj1327++
	if yyhl1327 {
		yyb1327 = yyj1327 > l
	} else {
		yyb1327 = r.CheckBreak()
	}
	if yyb1327 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1327++
	if yyhl1327 {
		yyb1327 = yyj1327 > l
	} else {
		yyb1327 = r.CheckBreak()
	}
	if yyb1327 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	for {
		yyj1327++
		if yyhl1327 {
			yyb1327 = yyj1327 > l
		} else {
			yyb1327 = r.CheckBreak()
		}
		if yyb1327 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1327-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 _, yyv1330 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1331 := &yyv1330
		yy1331.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

	yyv1332 := *v
	yyh1332, yyl1332 := z.DecSliceHelperStart()
	var yyc1332 bool
	if yyl1332 == 0 {
		if yyv1332 == nil {
			yyv1332 = []HorizontalPodAutoscaler{}
			yyc1332 = true
		} else if len(yyv1332) != 0 {
			yyv1332 = yyv1332[:0]
			yyc1332 = true
		}
	} else if yyl1332 > 0 {
		var yyrr1332, yyrl1332 int
		var yyrt1332 bool
		if yyl1332 > cap(yyv1332) {

			yyrg1332 := len(yyv1332) > 0
			yyv21332 := yyv1332
			yyrl1332, yyrt1332 = z.DecInferLen(yyl1332, z.DecBasicHandle().MaxInitLen, 320)
			if yyrt1332 {
				if yyrl1332 <= cap(yyv1332) {
					yyv1332 = yyv1332[:yyrl1332]
				} else {
					yyv1332 = make([]HorizontalPodAutoscaler, yyrl1332)
				}
			} else {
				yyv1332 = make([]HorizontalPodAutoscaler, yyrl1332)
			}
			yyc1332 = true
			yyrr1332 = len(yyv1332)
			if yyrg1332 {
				copy(yyv1332, yyv21332)
			}
		} else if yyl1332 != len(yyv1332) {
			yyv1332 = yyv1332[:yyl1332]
			yyc1332 = true
		}
		yyj1332 := 0
		for ; yyj1332 < yyrr1332; yyj1332++ {
			yyh1332.ElemContainerState(yyj1332)
			if r.TryDecodeAsNil() {
				yyv1332[yyj1332] = HorizontalPodAutoscaler{}
			} else {
				yyv1333 := &yyv1332[yyj1332]
				yyv1333.CodecDecodeSelf(d)
			}

		}
		if yyrt1332 {
			for ; yyj1332 < yyl1332; yyj1332++ {
				yyv1332 = append(yyv1332, HorizontalPodAutoscaler{})
				yyh1332.ElemContainerState(yyj1332)
				if r.TryDecodeAsNil() {
					yyv1332[yyj1332] = HorizontalPodAutoscaler{}
				} else {
					yyv1334 := &yyv1332[yyj1332]
					yyv1334.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1332 >= len(yyv1332) {
				yyv1332 = append(yyv1332, HorizontalPodAutoscaler{}) // var yyz1332 HorizontalPodAutoscaler
				yyc1332 = true
			}
			yyh1332.ElemContainerState(yyj1332)
			if yyj1332 < len(yyv1332) {
				if r.TryDecodeAsNil() {
					yyv1332[yyj1332] = HorizontalPodAutoscaler{}
				} else {
					yyv1335 := &yyv1332[yyj1332]
					yyv1335.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1332 < len(yyv1332) {
			yyv1332 = yyv1332[:yyj1332]
			yyc1332 = true
		} else if yyj1332 == 0 && yyv1332 == nil {
			yyv1332 = []HorizontalPodAutoscaler{}
			yyc1332 = true
		}
	}
	yyh1332.End()
	if yyc1332 {
		*v = yyv1332
	}
}

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 _, yyv1336 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1337 := &yyv1336
		yy1337.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

	yyv1338 := *v
	yyh1338, yyl1338 := z.DecSliceHelperStart()
	var yyc1338 bool
	if yyl1338 == 0 {
		if yyv1338 == nil {
			yyv1338 = []APIVersion{}
			yyc1338 = true
		} else if len(yyv1338) != 0 {
			yyv1338 = yyv1338[:0]
			yyc1338 = true
		}
	} else if yyl1338 > 0 {
		var yyrr1338, yyrl1338 int
		var yyrt1338 bool
		if yyl1338 > cap(yyv1338) {

			yyrg1338 := len(yyv1338) > 0
			yyv21338 := yyv1338
			yyrl1338, yyrt1338 = z.DecInferLen(yyl1338, z.DecBasicHandle().MaxInitLen, 32)
			if yyrt1338 {
				if yyrl1338 <= cap(yyv1338) {
					yyv1338 = yyv1338[:yyrl1338]
				} else {
					yyv1338 = make([]APIVersion, yyrl1338)
				}
			} else {
				yyv1338 = make([]APIVersion, yyrl1338)
			}
			yyc1338 = true
			yyrr1338 = len(yyv1338)
			if yyrg1338 {
				copy(yyv1338, yyv21338)
			}
		} else if yyl1338 != len(yyv1338) {
			yyv1338 = yyv1338[:yyl1338]
			yyc1338 = true
		}
		yyj1338 := 0
		for ; yyj1338 < yyrr1338; yyj1338++ {
			yyh1338.ElemContainerState(yyj1338)
			if r.TryDecodeAsNil() {
				yyv1338[yyj1338] = APIVersion{}
			} else {
				yyv1339 := &yyv1338[yyj1338]
				yyv1339.CodecDecodeSelf(d)
			}

		}
		if yyrt1338 {
			for ; yyj1338 < yyl1338; yyj1338++ {
				yyv1338 = append(yyv1338, APIVersion{})
				yyh1338.ElemContainerState(yyj1338)
				if r.TryDecodeAsNil() {
					yyv1338[yyj1338] = APIVersion{}
				} else {
					yyv1340 := &yyv1338[yyj1338]
					yyv1340.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1338 >= len(yyv1338) {
				yyv1338 = append(yyv1338, APIVersion{}) // var yyz1338 APIVersion
				yyc1338 = true
			}
			yyh1338.ElemContainerState(yyj1338)
			if yyj1338 < len(yyv1338) {
				if r.TryDecodeAsNil() {
					yyv1338[yyj1338] = APIVersion{}
				} else {
					yyv1341 := &yyv1338[yyj1338]
					yyv1341.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1338 < len(yyv1338) {
			yyv1338 = yyv1338[:yyj1338]
			yyc1338 = true
		} else if yyj1338 == 0 && yyv1338 == nil {
			yyv1338 = []APIVersion{}
			yyc1338 = true
		}
	}
	yyh1338.End()
	if yyc1338 {
		*v = yyv1338
	}
}

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 _, yyv1342 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1343 := &yyv1342
		yy1343.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

	yyv1344 := *v
	yyh1344, yyl1344 := z.DecSliceHelperStart()
	var yyc1344 bool
	if yyl1344 == 0 {
		if yyv1344 == nil {
			yyv1344 = []ThirdPartyResource{}
			yyc1344 = true
		} else if len(yyv1344) != 0 {
			yyv1344 = yyv1344[:0]
			yyc1344 = true
		}
	} else if yyl1344 > 0 {
		var yyrr1344, yyrl1344 int
		var yyrt1344 bool
		if yyl1344 > cap(yyv1344) {

			yyrg1344 := len(yyv1344) > 0
			yyv21344 := yyv1344
			yyrl1344, yyrt1344 = z.DecInferLen(yyl1344, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1344 {
				if yyrl1344 <= cap(yyv1344) {
					yyv1344 = yyv1344[:yyrl1344]
				} else {
					yyv1344 = make([]ThirdPartyResource, yyrl1344)
				}
			} else {
				yyv1344 = make([]ThirdPartyResource, yyrl1344)
			}
			yyc1344 = true
			yyrr1344 = len(yyv1344)
			if yyrg1344 {
				copy(yyv1344, yyv21344)
			}
		} else if yyl1344 != len(yyv1344) {
			yyv1344 = yyv1344[:yyl1344]
			yyc1344 = true
		}
		yyj1344 := 0
		for ; yyj1344 < yyrr1344; yyj1344++ {
			yyh1344.ElemContainerState(yyj1344)
			if r.TryDecodeAsNil() {
				yyv1344[yyj1344] = ThirdPartyResource{}
			} else {
				yyv1345 := &yyv1344[yyj1344]
				yyv1345.CodecDecodeSelf(d)
			}

		}
		if yyrt1344 {
			for ; yyj1344 < yyl1344; yyj1344++ {
				yyv1344 = append(yyv1344, ThirdPartyResource{})
				yyh1344.ElemContainerState(yyj1344)
				if r.TryDecodeAsNil() {
					yyv1344[yyj1344] = ThirdPartyResource{}
				} else {
					yyv1346 := &yyv1344[yyj1344]
					yyv1346.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1344 >= len(yyv1344) {
				yyv1344 = append(yyv1344, ThirdPartyResource{}) // var yyz1344 ThirdPartyResource
				yyc1344 = true
			}
			yyh1344.ElemContainerState(yyj1344)
			if yyj1344 < len(yyv1344) {
				if r.TryDecodeAsNil() {
					yyv1344[yyj1344] = ThirdPartyResource{}
				} else {
					yyv1347 := &yyv1344[yyj1344]
					yyv1347.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1344 < len(yyv1344) {
			yyv1344 = yyv1344[:yyj1344]
			yyc1344 = true
		} else if yyj1344 == 0 && yyv1344 == nil {
			yyv1344 = []ThirdPartyResource{}
			yyc1344 = true
		}
	}
	yyh1344.End()
	if yyc1344 {
		*v = yyv1344
	}
}

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 _, yyv1348 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1349 := &yyv1348
		yy1349.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

	yyv1350 := *v
	yyh1350, yyl1350 := z.DecSliceHelperStart()
	var yyc1350 bool
	if yyl1350 == 0 {
		if yyv1350 == nil {
			yyv1350 = []Deployment{}
			yyc1350 = true
		} else if len(yyv1350) != 0 {
			yyv1350 = yyv1350[:0]
			yyc1350 = true
		}
	} else if yyl1350 > 0 {
		var yyrr1350, yyrl1350 int
		var yyrt1350 bool
		if yyl1350 > cap(yyv1350) {

			yyrg1350 := len(yyv1350) > 0
			yyv21350 := yyv1350
			yyrl1350, yyrt1350 = z.DecInferLen(yyl1350, z.DecBasicHandle().MaxInitLen, 592)
			if yyrt1350 {
				if yyrl1350 <= cap(yyv1350) {
					yyv1350 = yyv1350[:yyrl1350]
				} else {
					yyv1350 = make([]Deployment, yyrl1350)
				}
			} else {
				yyv1350 = make([]Deployment, yyrl1350)
			}
			yyc1350 = true
			yyrr1350 = len(yyv1350)
			if yyrg1350 {
				copy(yyv1350, yyv21350)
			}
		} else if yyl1350 != len(yyv1350) {
			yyv1350 = yyv1350[:yyl1350]
			yyc1350 = true
		}
		yyj1350 := 0
		for ; yyj1350 < yyrr1350; yyj1350++ {
			yyh1350.ElemContainerState(yyj1350)
			if r.TryDecodeAsNil() {
				yyv1350[yyj1350] = Deployment{}
			} else {
				yyv1351 := &yyv1350[yyj1350]
				yyv1351.CodecDecodeSelf(d)
			}

		}
		if yyrt1350 {
			for ; yyj1350 < yyl1350; yyj1350++ {
				yyv1350 = append(yyv1350, Deployment{})
				yyh1350.ElemContainerState(yyj1350)
				if r.TryDecodeAsNil() {
					yyv1350[yyj1350] = Deployment{}
				} else {
					yyv1352 := &yyv1350[yyj1350]
					yyv1352.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1350 >= len(yyv1350) {
				yyv1350 = append(yyv1350, Deployment{}) // var yyz1350 Deployment
				yyc1350 = true
			}
			yyh1350.ElemContainerState(yyj1350)
			if yyj1350 < len(yyv1350) {
				if r.TryDecodeAsNil() {
					yyv1350[yyj1350] = Deployment{}
				} else {
					yyv1353 := &yyv1350[yyj1350]
					yyv1353.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1350 < len(yyv1350) {
			yyv1350 = yyv1350[:yyj1350]
			yyc1350 = true
		} else if yyj1350 == 0 && yyv1350 == nil {
			yyv1350 = []Deployment{}
			yyc1350 = true
		}
	}
	yyh1350.End()
	if yyc1350 {
		*v = yyv1350
	}
}

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 _, yyv1354 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1355 := &yyv1354
		yy1355.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

	yyv1356 := *v
	yyh1356, yyl1356 := z.DecSliceHelperStart()
	var yyc1356 bool
	if yyl1356 == 0 {
		if yyv1356 == nil {
			yyv1356 = []DaemonSet{}
			yyc1356 = true
		} else if len(yyv1356) != 0 {
			yyv1356 = yyv1356[:0]
			yyc1356 = true
		}
	} else if yyl1356 > 0 {
		var yyrr1356, yyrl1356 int
		var yyrt1356 bool
		if yyl1356 > cap(yyv1356) {

			yyrg1356 := len(yyv1356) > 0
			yyv21356 := yyv1356
			yyrl1356, yyrt1356 = z.DecInferLen(yyl1356, z.DecBasicHandle().MaxInitLen, 272)
			if yyrt1356 {
				if yyrl1356 <= cap(yyv1356) {
					yyv1356 = yyv1356[:yyrl1356]
				} else {
					yyv1356 = make([]DaemonSet, yyrl1356)
				}
			} else {
				yyv1356 = make([]DaemonSet, yyrl1356)
			}
			yyc1356 = true
			yyrr1356 = len(yyv1356)
			if yyrg1356 {
				copy(yyv1356, yyv21356)
			}
		} else if yyl1356 != len(yyv1356) {
			yyv1356 = yyv1356[:yyl1356]
			yyc1356 = true
		}
		yyj1356 := 0
		for ; yyj1356 < yyrr1356; yyj1356++ {
			yyh1356.ElemContainerState(yyj1356)
			if r.TryDecodeAsNil() {
				yyv1356[yyj1356] = DaemonSet{}
			} else {
				yyv1357 := &yyv1356[yyj1356]
				yyv1357.CodecDecodeSelf(d)
			}

		}
		if yyrt1356 {
			for ; yyj1356 < yyl1356; yyj1356++ {
				yyv1356 = append(yyv1356, DaemonSet{})
				yyh1356.ElemContainerState(yyj1356)
				if r.TryDecodeAsNil() {
					yyv1356[yyj1356] = DaemonSet{}
				} else {
					yyv1358 := &yyv1356[yyj1356]
					yyv1358.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1356 >= len(yyv1356) {
				yyv1356 = append(yyv1356, DaemonSet{}) // var yyz1356 DaemonSet
				yyc1356 = true
			}
			yyh1356.ElemContainerState(yyj1356)
			if yyj1356 < len(yyv1356) {
				if r.TryDecodeAsNil() {
					yyv1356[yyj1356] = DaemonSet{}
				} else {
					yyv1359 := &yyv1356[yyj1356]
					yyv1359.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1356 < len(yyv1356) {
			yyv1356 = yyv1356[:yyj1356]
			yyc1356 = true
		} else if yyj1356 == 0 && yyv1356 == nil {
			yyv1356 = []DaemonSet{}
			yyc1356 = true
		}
	}
	yyh1356.End()
	if yyc1356 {
		*v = yyv1356
	}
}

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 _, yyv1360 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1361 := &yyv1360
		yy1361.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

	yyv1362 := *v
	yyh1362, yyl1362 := z.DecSliceHelperStart()
	var yyc1362 bool
	if yyl1362 == 0 {
		if yyv1362 == nil {
			yyv1362 = []ThirdPartyResourceData{}
			yyc1362 = true
		} else if len(yyv1362) != 0 {
			yyv1362 = yyv1362[:0]
			yyc1362 = true
		}
	} else if yyl1362 > 0 {
		var yyrr1362, yyrl1362 int
		var yyrt1362 bool
		if yyl1362 > cap(yyv1362) {

			yyrg1362 := len(yyv1362) > 0
			yyv21362 := yyv1362
			yyrl1362, yyrt1362 = z.DecInferLen(yyl1362, z.DecBasicHandle().MaxInitLen, 216)
			if yyrt1362 {
				if yyrl1362 <= cap(yyv1362) {
					yyv1362 = yyv1362[:yyrl1362]
				} else {
					yyv1362 = make([]ThirdPartyResourceData, yyrl1362)
				}
			} else {
				yyv1362 = make([]ThirdPartyResourceData, yyrl1362)
			}
			yyc1362 = true
			yyrr1362 = len(yyv1362)
			if yyrg1362 {
				copy(yyv1362, yyv21362)
			}
		} else if yyl1362 != len(yyv1362) {
			yyv1362 = yyv1362[:yyl1362]
			yyc1362 = true
		}
		yyj1362 := 0
		for ; yyj1362 < yyrr1362; yyj1362++ {
			yyh1362.ElemContainerState(yyj1362)
			if r.TryDecodeAsNil() {
				yyv1362[yyj1362] = ThirdPartyResourceData{}
			} else {
				yyv1363 := &yyv1362[yyj1362]
				yyv1363.CodecDecodeSelf(d)
			}

		}
		if yyrt1362 {
			for ; yyj1362 < yyl1362; yyj1362++ {
				yyv1362 = append(yyv1362, ThirdPartyResourceData{})
				yyh1362.ElemContainerState(yyj1362)
				if r.TryDecodeAsNil() {
					yyv1362[yyj1362] = ThirdPartyResourceData{}
				} else {
					yyv1364 := &yyv1362[yyj1362]
					yyv1364.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1362 >= len(yyv1362) {
				yyv1362 = append(yyv1362, ThirdPartyResourceData{}) // var yyz1362 ThirdPartyResourceData
				yyc1362 = true
			}
			yyh1362.ElemContainerState(yyj1362)
			if yyj1362 < len(yyv1362) {
				if r.TryDecodeAsNil() {
					yyv1362[yyj1362] = ThirdPartyResourceData{}
				} else {
					yyv1365 := &yyv1362[yyj1362]
					yyv1365.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1362 < len(yyv1362) {
			yyv1362 = yyv1362[:yyj1362]
			yyc1362 = true
		} else if yyj1362 == 0 && yyv1362 == nil {
			yyv1362 = []ThirdPartyResourceData{}
			yyc1362 = true
		}
	}
	yyh1362.End()
	if yyc1362 {
		*v = yyv1362
	}
}

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 _, yyv1366 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1367 := &yyv1366
		yy1367.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

	yyv1368 := *v
	yyh1368, yyl1368 := z.DecSliceHelperStart()
	var yyc1368 bool
	if yyl1368 == 0 {
		if yyv1368 == nil {
			yyv1368 = []Job{}
			yyc1368 = true
		} else if len(yyv1368) != 0 {
			yyv1368 = yyv1368[:0]
			yyc1368 = true
		}
	} else if yyl1368 > 0 {
		var yyrr1368, yyrl1368 int
		var yyrt1368 bool
		if yyl1368 > cap(yyv1368) {

			yyrg1368 := len(yyv1368) > 0
			yyv21368 := yyv1368
			yyrl1368, yyrt1368 = z.DecInferLen(yyl1368, z.DecBasicHandle().MaxInitLen, 616)
			if yyrt1368 {
				if yyrl1368 <= cap(yyv1368) {
					yyv1368 = yyv1368[:yyrl1368]
				} else {
					yyv1368 = make([]Job, yyrl1368)
				}
			} else {
				yyv1368 = make([]Job, yyrl1368)
			}
			yyc1368 = true
			yyrr1368 = len(yyv1368)
			if yyrg1368 {
				copy(yyv1368, yyv21368)
			}
		} else if yyl1368 != len(yyv1368) {
			yyv1368 = yyv1368[:yyl1368]
			yyc1368 = true
		}
		yyj1368 := 0
		for ; yyj1368 < yyrr1368; yyj1368++ {
			yyh1368.ElemContainerState(yyj1368)
			if r.TryDecodeAsNil() {
				yyv1368[yyj1368] = Job{}
			} else {
				yyv1369 := &yyv1368[yyj1368]
				yyv1369.CodecDecodeSelf(d)
			}

		}
		if yyrt1368 {
			for ; yyj1368 < yyl1368; yyj1368++ {
				yyv1368 = append(yyv1368, Job{})
				yyh1368.ElemContainerState(yyj1368)
				if r.TryDecodeAsNil() {
					yyv1368[yyj1368] = Job{}
				} else {
					yyv1370 := &yyv1368[yyj1368]
					yyv1370.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1368 >= len(yyv1368) {
				yyv1368 = append(yyv1368, Job{}) // var yyz1368 Job
				yyc1368 = true
			}
			yyh1368.ElemContainerState(yyj1368)
			if yyj1368 < len(yyv1368) {
				if r.TryDecodeAsNil() {
					yyv1368[yyj1368] = Job{}
				} else {
					yyv1371 := &yyv1368[yyj1368]
					yyv1371.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1368 < len(yyv1368) {
			yyv1368 = yyv1368[:yyj1368]
			yyc1368 = true
		} else if yyj1368 == 0 && yyv1368 == nil {
			yyv1368 = []Job{}
			yyc1368 = true
		}
	}
	yyh1368.End()
	if yyc1368 {
		*v = yyv1368
	}
}

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 _, yyv1372 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1373 := &yyv1372
		yy1373.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

	yyv1374 := *v
	yyh1374, yyl1374 := z.DecSliceHelperStart()
	var yyc1374 bool
	if yyl1374 == 0 {
		if yyv1374 == nil {
			yyv1374 = []JobCondition{}
			yyc1374 = true
		} else if len(yyv1374) != 0 {
			yyv1374 = yyv1374[:0]
			yyc1374 = true
		}
	} else if yyl1374 > 0 {
		var yyrr1374, yyrl1374 int
		var yyrt1374 bool
		if yyl1374 > cap(yyv1374) {

			yyrg1374 := len(yyv1374) > 0
			yyv21374 := yyv1374
			yyrl1374, yyrt1374 = z.DecInferLen(yyl1374, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1374 {
				if yyrl1374 <= cap(yyv1374) {
					yyv1374 = yyv1374[:yyrl1374]
				} else {
					yyv1374 = make([]JobCondition, yyrl1374)
				}
			} else {
				yyv1374 = make([]JobCondition, yyrl1374)
			}
			yyc1374 = true
			yyrr1374 = len(yyv1374)
			if yyrg1374 {
				copy(yyv1374, yyv21374)
			}
		} else if yyl1374 != len(yyv1374) {
			yyv1374 = yyv1374[:yyl1374]
			yyc1374 = true
		}
		yyj1374 := 0
		for ; yyj1374 < yyrr1374; yyj1374++ {
			yyh1374.ElemContainerState(yyj1374)
			if r.TryDecodeAsNil() {
				yyv1374[yyj1374] = JobCondition{}
			} else {
				yyv1375 := &yyv1374[yyj1374]
				yyv1375.CodecDecodeSelf(d)
			}

		}
		if yyrt1374 {
			for ; yyj1374 < yyl1374; yyj1374++ {
				yyv1374 = append(yyv1374, JobCondition{})
				yyh1374.ElemContainerState(yyj1374)
				if r.TryDecodeAsNil() {
					yyv1374[yyj1374] = JobCondition{}
				} else {
					yyv1376 := &yyv1374[yyj1374]
					yyv1376.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1374 >= len(yyv1374) {
				yyv1374 = append(yyv1374, JobCondition{}) // var yyz1374 JobCondition
				yyc1374 = true
			}
			yyh1374.ElemContainerState(yyj1374)
			if yyj1374 < len(yyv1374) {
				if r.TryDecodeAsNil() {
					yyv1374[yyj1374] = JobCondition{}
				} else {
					yyv1377 := &yyv1374[yyj1374]
					yyv1377.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1374 < len(yyv1374) {
			yyv1374 = yyv1374[:yyj1374]
			yyc1374 = true
		} else if yyj1374 == 0 && yyv1374 == nil {
			yyv1374 = []JobCondition{}
			yyc1374 = true
		}
	}
	yyh1374.End()
	if yyc1374 {
		*v = yyv1374
	}
}

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 _, yyv1378 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1379 := &yyv1378
		yy1379.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

	yyv1380 := *v
	yyh1380, yyl1380 := z.DecSliceHelperStart()
	var yyc1380 bool
	if yyl1380 == 0 {
		if yyv1380 == nil {
			yyv1380 = []Ingress{}
			yyc1380 = true
		} else if len(yyv1380) != 0 {
			yyv1380 = yyv1380[:0]
			yyc1380 = true
		}
	} else if yyl1380 > 0 {
		var yyrr1380, yyrl1380 int
		var yyrt1380 bool
		if yyl1380 > cap(yyv1380) {

			yyrg1380 := len(yyv1380) > 0
			yyv21380 := yyv1380
			yyrl1380, yyrt1380 = z.DecInferLen(yyl1380, z.DecBasicHandle().MaxInitLen, 248)
			if yyrt1380 {
				if yyrl1380 <= cap(yyv1380) {
					yyv1380 = yyv1380[:yyrl1380]
				} else {
					yyv1380 = make([]Ingress, yyrl1380)
				}
			} else {
				yyv1380 = make([]Ingress, yyrl1380)
			}
			yyc1380 = true
			yyrr1380 = len(yyv1380)
			if yyrg1380 {
				copy(yyv1380, yyv21380)
			}
		} else if yyl1380 != len(yyv1380) {
			yyv1380 = yyv1380[:yyl1380]
			yyc1380 = true
		}
		yyj1380 := 0
		for ; yyj1380 < yyrr1380; yyj1380++ {
			yyh1380.ElemContainerState(yyj1380)
			if r.TryDecodeAsNil() {
				yyv1380[yyj1380] = Ingress{}
			} else {
				yyv1381 := &yyv1380[yyj1380]
				yyv1381.CodecDecodeSelf(d)
			}

		}
		if yyrt1380 {
			for ; yyj1380 < yyl1380; yyj1380++ {
				yyv1380 = append(yyv1380, Ingress{})
				yyh1380.ElemContainerState(yyj1380)
				if r.TryDecodeAsNil() {
					yyv1380[yyj1380] = Ingress{}
				} else {
					yyv1382 := &yyv1380[yyj1380]
					yyv1382.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1380 >= len(yyv1380) {
				yyv1380 = append(yyv1380, Ingress{}) // var yyz1380 Ingress
				yyc1380 = true
			}
			yyh1380.ElemContainerState(yyj1380)
			if yyj1380 < len(yyv1380) {
				if r.TryDecodeAsNil() {
					yyv1380[yyj1380] = Ingress{}
				} else {
					yyv1383 := &yyv1380[yyj1380]
					yyv1383.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1380 < len(yyv1380) {
			yyv1380 = yyv1380[:yyj1380]
			yyc1380 = true
		} else if yyj1380 == 0 && yyv1380 == nil {
			yyv1380 = []Ingress{}
			yyc1380 = true
		}
	}
	yyh1380.End()
	if yyc1380 {
		*v = yyv1380
	}
}

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 _, yyv1384 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1385 := &yyv1384
		yy1385.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

	yyv1386 := *v
	yyh1386, yyl1386 := z.DecSliceHelperStart()
	var yyc1386 bool
	if yyl1386 == 0 {
		if yyv1386 == nil {
			yyv1386 = []IngressRule{}
			yyc1386 = true
		} else if len(yyv1386) != 0 {
			yyv1386 = yyv1386[:0]
			yyc1386 = true
		}
	} else if yyl1386 > 0 {
		var yyrr1386, yyrl1386 int
		var yyrt1386 bool
		if yyl1386 > cap(yyv1386) {

			yyrg1386 := len(yyv1386) > 0
			yyv21386 := yyv1386
			yyrl1386, yyrt1386 = z.DecInferLen(yyl1386, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1386 {
				if yyrl1386 <= cap(yyv1386) {
					yyv1386 = yyv1386[:yyrl1386]
				} else {
					yyv1386 = make([]IngressRule, yyrl1386)
				}
			} else {
				yyv1386 = make([]IngressRule, yyrl1386)
			}
			yyc1386 = true
			yyrr1386 = len(yyv1386)
			if yyrg1386 {
				copy(yyv1386, yyv21386)
			}
		} else if yyl1386 != len(yyv1386) {
			yyv1386 = yyv1386[:yyl1386]
			yyc1386 = true
		}
		yyj1386 := 0
		for ; yyj1386 < yyrr1386; yyj1386++ {
			yyh1386.ElemContainerState(yyj1386)
			if r.TryDecodeAsNil() {
				yyv1386[yyj1386] = IngressRule{}
			} else {
				yyv1387 := &yyv1386[yyj1386]
				yyv1387.CodecDecodeSelf(d)
			}

		}
		if yyrt1386 {
			for ; yyj1386 < yyl1386; yyj1386++ {
				yyv1386 = append(yyv1386, IngressRule{})
				yyh1386.ElemContainerState(yyj1386)
				if r.TryDecodeAsNil() {
					yyv1386[yyj1386] = IngressRule{}
				} else {
					yyv1388 := &yyv1386[yyj1386]
					yyv1388.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1386 >= len(yyv1386) {
				yyv1386 = append(yyv1386, IngressRule{}) // var yyz1386 IngressRule
				yyc1386 = true
			}
			yyh1386.ElemContainerState(yyj1386)
			if yyj1386 < len(yyv1386) {
				if r.TryDecodeAsNil() {
					yyv1386[yyj1386] = IngressRule{}
				} else {
					yyv1389 := &yyv1386[yyj1386]
					yyv1389.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1386 < len(yyv1386) {
			yyv1386 = yyv1386[:yyj1386]
			yyc1386 = true
		} else if yyj1386 == 0 && yyv1386 == nil {
			yyv1386 = []IngressRule{}
			yyc1386 = true
		}
	}
	yyh1386.End()
	if yyc1386 {
		*v = yyv1386
	}
}

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 _, yyv1390 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1391 := &yyv1390
		yy1391.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

	yyv1392 := *v
	yyh1392, yyl1392 := z.DecSliceHelperStart()
	var yyc1392 bool
	if yyl1392 == 0 {
		if yyv1392 == nil {
			yyv1392 = []HTTPIngressPath{}
			yyc1392 = true
		} else if len(yyv1392) != 0 {
			yyv1392 = yyv1392[:0]
			yyc1392 = true
		}
	} else if yyl1392 > 0 {
		var yyrr1392, yyrl1392 int
		var yyrt1392 bool
		if yyl1392 > cap(yyv1392) {

			yyrg1392 := len(yyv1392) > 0
			yyv21392 := yyv1392
			yyrl1392, yyrt1392 = z.DecInferLen(yyl1392, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1392 {
				if yyrl1392 <= cap(yyv1392) {
					yyv1392 = yyv1392[:yyrl1392]
				} else {
					yyv1392 = make([]HTTPIngressPath, yyrl1392)
				}
			} else {
				yyv1392 = make([]HTTPIngressPath, yyrl1392)
			}
			yyc1392 = true
			yyrr1392 = len(yyv1392)
			if yyrg1392 {
				copy(yyv1392, yyv21392)
			}
		} else if yyl1392 != len(yyv1392) {
			yyv1392 = yyv1392[:yyl1392]
			yyc1392 = true
		}
		yyj1392 := 0
		for ; yyj1392 < yyrr1392; yyj1392++ {
			yyh1392.ElemContainerState(yyj1392)
			if r.TryDecodeAsNil() {
				yyv1392[yyj1392] = HTTPIngressPath{}
			} else {
				yyv1393 := &yyv1392[yyj1392]
				yyv1393.CodecDecodeSelf(d)
			}

		}
		if yyrt1392 {
			for ; yyj1392 < yyl1392; yyj1392++ {
				yyv1392 = append(yyv1392, HTTPIngressPath{})
				yyh1392.ElemContainerState(yyj1392)
				if r.TryDecodeAsNil() {
					yyv1392[yyj1392] = HTTPIngressPath{}
				} else {
					yyv1394 := &yyv1392[yyj1392]
					yyv1394.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1392 >= len(yyv1392) {
				yyv1392 = append(yyv1392, HTTPIngressPath{}) // var yyz1392 HTTPIngressPath
				yyc1392 = true
			}
			yyh1392.ElemContainerState(yyj1392)
			if yyj1392 < len(yyv1392) {
				if r.TryDecodeAsNil() {
					yyv1392[yyj1392] = HTTPIngressPath{}
				} else {
					yyv1395 := &yyv1392[yyj1392]
					yyv1395.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1392 < len(yyv1392) {
			yyv1392 = yyv1392[:yyj1392]
			yyc1392 = true
		} else if yyj1392 == 0 && yyv1392 == nil {
			yyv1392 = []HTTPIngressPath{}
			yyc1392 = true
		}
	}
	yyh1392.End()
	if yyc1392 {
		*v = yyv1392
	}
}

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 _, yyv1396 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1397 := &yyv1396
		yy1397.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

	yyv1398 := *v
	yyh1398, yyl1398 := z.DecSliceHelperStart()
	var yyc1398 bool
	if yyl1398 == 0 {
		if yyv1398 == nil {
			yyv1398 = []NodeUtilization{}
			yyc1398 = true
		} else if len(yyv1398) != 0 {
			yyv1398 = yyv1398[:0]
			yyc1398 = true
		}
	} else if yyl1398 > 0 {
		var yyrr1398, yyrl1398 int
		var yyrt1398 bool
		if yyl1398 > cap(yyv1398) {

			yyrg1398 := len(yyv1398) > 0
			yyv21398 := yyv1398
			yyrl1398, yyrt1398 = z.DecInferLen(yyl1398, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1398 {
				if yyrl1398 <= cap(yyv1398) {
					yyv1398 = yyv1398[:yyrl1398]
				} else {
					yyv1398 = make([]NodeUtilization, yyrl1398)
				}
			} else {
				yyv1398 = make([]NodeUtilization, yyrl1398)
			}
			yyc1398 = true
			yyrr1398 = len(yyv1398)
			if yyrg1398 {
				copy(yyv1398, yyv21398)
			}
		} else if yyl1398 != len(yyv1398) {
			yyv1398 = yyv1398[:yyl1398]
			yyc1398 = true
		}
		yyj1398 := 0
		for ; yyj1398 < yyrr1398; yyj1398++ {
			yyh1398.ElemContainerState(yyj1398)
			if r.TryDecodeAsNil() {
				yyv1398[yyj1398] = NodeUtilization{}
			} else {
				yyv1399 := &yyv1398[yyj1398]
				yyv1399.CodecDecodeSelf(d)
			}

		}
		if yyrt1398 {
			for ; yyj1398 < yyl1398; yyj1398++ {
				yyv1398 = append(yyv1398, NodeUtilization{})
				yyh1398.ElemContainerState(yyj1398)
				if r.TryDecodeAsNil() {
					yyv1398[yyj1398] = NodeUtilization{}
				} else {
					yyv1400 := &yyv1398[yyj1398]
					yyv1400.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1398 >= len(yyv1398) {
				yyv1398 = append(yyv1398, NodeUtilization{}) // var yyz1398 NodeUtilization
				yyc1398 = true
			}
			yyh1398.ElemContainerState(yyj1398)
			if yyj1398 < len(yyv1398) {
				if r.TryDecodeAsNil() {
					yyv1398[yyj1398] = NodeUtilization{}
				} else {
					yyv1401 := &yyv1398[yyj1398]
					yyv1401.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1398 < len(yyv1398) {
			yyv1398 = yyv1398[:yyj1398]
			yyc1398 = true
		} else if yyj1398 == 0 && yyv1398 == nil {
			yyv1398 = []NodeUtilization{}
			yyc1398 = true
		}
	}
	yyh1398.End()
	if yyc1398 {
		*v = yyv1398
	}
}

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 _, yyv1402 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1403 := &yyv1402
		yy1403.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

	yyv1404 := *v
	yyh1404, yyl1404 := z.DecSliceHelperStart()
	var yyc1404 bool
	if yyl1404 == 0 {
		if yyv1404 == nil {
			yyv1404 = []ClusterAutoscaler{}
			yyc1404 = true
		} else if len(yyv1404) != 0 {
			yyv1404 = yyv1404[:0]
			yyc1404 = true
		}
	} else if yyl1404 > 0 {
		var yyrr1404, yyrl1404 int
		var yyrt1404 bool
		if yyl1404 > cap(yyv1404) {

			yyrg1404 := len(yyv1404) > 0
			yyv21404 := yyv1404
			yyrl1404, yyrt1404 = z.DecInferLen(yyl1404, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1404 {
				if yyrl1404 <= cap(yyv1404) {
					yyv1404 = yyv1404[:yyrl1404]
				} else {
					yyv1404 = make([]ClusterAutoscaler, yyrl1404)
				}
			} else {
				yyv1404 = make([]ClusterAutoscaler, yyrl1404)
			}
			yyc1404 = true
			yyrr1404 = len(yyv1404)
			if yyrg1404 {
				copy(yyv1404, yyv21404)
			}
		} else if yyl1404 != len(yyv1404) {
			yyv1404 = yyv1404[:yyl1404]
			yyc1404 = true
		}
		yyj1404 := 0
		for ; yyj1404 < yyrr1404; yyj1404++ {
			yyh1404.ElemContainerState(yyj1404)
			if r.TryDecodeAsNil() {
				yyv1404[yyj1404] = ClusterAutoscaler{}
			} else {
				yyv1405 := &yyv1404[yyj1404]
				yyv1405.CodecDecodeSelf(d)
			}

		}
		if yyrt1404 {
			for ; yyj1404 < yyl1404; yyj1404++ {
				yyv1404 = append(yyv1404, ClusterAutoscaler{})
				yyh1404.ElemContainerState(yyj1404)
				if r.TryDecodeAsNil() {
					yyv1404[yyj1404] = ClusterAutoscaler{}
				} else {
					yyv1406 := &yyv1404[yyj1404]
					yyv1406.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1404 >= len(yyv1404) {
				yyv1404 = append(yyv1404, ClusterAutoscaler{}) // var yyz1404 ClusterAutoscaler
				yyc1404 = true
			}
			yyh1404.ElemContainerState(yyj1404)
			if yyj1404 < len(yyv1404) {
				if r.TryDecodeAsNil() {
					yyv1404[yyj1404] = ClusterAutoscaler{}
				} else {
					yyv1407 := &yyv1404[yyj1404]
					yyv1407.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1404 < len(yyv1404) {
			yyv1404 = yyv1404[:yyj1404]
			yyc1404 = true
		} else if yyj1404 == 0 && yyv1404 == nil {
			yyv1404 = []ClusterAutoscaler{}
			yyc1404 = true
		}
	}
	yyh1404.End()
	if yyc1404 {
		*v = yyv1404
	}
}

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 _, yyv1408 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1409 := &yyv1408
		yy1409.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

	yyv1410 := *v
	yyh1410, yyl1410 := z.DecSliceHelperStart()
	var yyc1410 bool
	if yyl1410 == 0 {
		if yyv1410 == nil {
			yyv1410 = []LabelSelectorRequirement{}
			yyc1410 = true
		} else if len(yyv1410) != 0 {
			yyv1410 = yyv1410[:0]
			yyc1410 = true
		}
	} else if yyl1410 > 0 {
		var yyrr1410, yyrl1410 int
		var yyrt1410 bool
		if yyl1410 > cap(yyv1410) {

			yyrg1410 := len(yyv1410) > 0
			yyv21410 := yyv1410
			yyrl1410, yyrt1410 = z.DecInferLen(yyl1410, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt1410 {
				if yyrl1410 <= cap(yyv1410) {
					yyv1410 = yyv1410[:yyrl1410]
				} else {
					yyv1410 = make([]LabelSelectorRequirement, yyrl1410)
				}
			} else {
				yyv1410 = make([]LabelSelectorRequirement, yyrl1410)
			}
			yyc1410 = true
			yyrr1410 = len(yyv1410)
			if yyrg1410 {
				copy(yyv1410, yyv21410)
			}
		} else if yyl1410 != len(yyv1410) {
			yyv1410 = yyv1410[:yyl1410]
			yyc1410 = true
		}
		yyj1410 := 0
		for ; yyj1410 < yyrr1410; yyj1410++ {
			yyh1410.ElemContainerState(yyj1410)
			if r.TryDecodeAsNil() {
				yyv1410[yyj1410] = LabelSelectorRequirement{}
			} else {
				yyv1411 := &yyv1410[yyj1410]
				yyv1411.CodecDecodeSelf(d)
			}

		}
		if yyrt1410 {
			for ; yyj1410 < yyl1410; yyj1410++ {
				yyv1410 = append(yyv1410, LabelSelectorRequirement{})
				yyh1410.ElemContainerState(yyj1410)
				if r.TryDecodeAsNil() {
					yyv1410[yyj1410] = LabelSelectorRequirement{}
				} else {
					yyv1412 := &yyv1410[yyj1410]
					yyv1412.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1410 >= len(yyv1410) {
				yyv1410 = append(yyv1410, LabelSelectorRequirement{}) // var yyz1410 LabelSelectorRequirement
				yyc1410 = true
			}
			yyh1410.ElemContainerState(yyj1410)
			if yyj1410 < len(yyv1410) {
				if r.TryDecodeAsNil() {
					yyv1410[yyj1410] = LabelSelectorRequirement{}
				} else {
					yyv1413 := &yyv1410[yyj1410]
					yyv1413.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1410 < len(yyv1410) {
			yyv1410 = yyv1410[:yyj1410]
			yyc1410 = true
		} else if yyj1410 == 0 && yyv1410 == nil {
			yyv1410 = []LabelSelectorRequirement{}
			yyc1410 = true
		}
	}
	yyh1410.End()
	if yyc1410 {
		*v = yyv1410
	}
}

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 _, yyv1414 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1415 := &yyv1414
		yy1415.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

	yyv1416 := *v
	yyh1416, yyl1416 := z.DecSliceHelperStart()
	var yyc1416 bool
	if yyl1416 == 0 {
		if yyv1416 == nil {
			yyv1416 = []ConfigMap{}
			yyc1416 = true
		} else if len(yyv1416) != 0 {
			yyv1416 = yyv1416[:0]
			yyc1416 = true
		}
	} else if yyl1416 > 0 {
		var yyrr1416, yyrl1416 int
		var yyrt1416 bool
		if yyl1416 > cap(yyv1416) {

			yyrg1416 := len(yyv1416) > 0
			yyv21416 := yyv1416
			yyrl1416, yyrt1416 = z.DecInferLen(yyl1416, z.DecBasicHandle().MaxInitLen, 200)
			if yyrt1416 {
				if yyrl1416 <= cap(yyv1416) {
					yyv1416 = yyv1416[:yyrl1416]
				} else {
					yyv1416 = make([]ConfigMap, yyrl1416)
				}
			} else {
				yyv1416 = make([]ConfigMap, yyrl1416)
			}
			yyc1416 = true
			yyrr1416 = len(yyv1416)
			if yyrg1416 {
				copy(yyv1416, yyv21416)
			}
		} else if yyl1416 != len(yyv1416) {
			yyv1416 = yyv1416[:yyl1416]
			yyc1416 = true
		}
		yyj1416 := 0
		for ; yyj1416 < yyrr1416; yyj1416++ {
			yyh1416.ElemContainerState(yyj1416)
			if r.TryDecodeAsNil() {
				yyv1416[yyj1416] = ConfigMap{}
			} else {
				yyv1417 := &yyv1416[yyj1416]
				yyv1417.CodecDecodeSelf(d)
			}

		}
		if yyrt1416 {
			for ; yyj1416 < yyl1416; yyj1416++ {
				yyv1416 = append(yyv1416, ConfigMap{})
				yyh1416.ElemContainerState(yyj1416)
				if r.TryDecodeAsNil() {
					yyv1416[yyj1416] = ConfigMap{}
				} else {
					yyv1418 := &yyv1416[yyj1416]
					yyv1418.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1416 >= len(yyv1416) {
				yyv1416 = append(yyv1416, ConfigMap{}) // var yyz1416 ConfigMap
				yyc1416 = true
			}
			yyh1416.ElemContainerState(yyj1416)
			if yyj1416 < len(yyv1416) {
				if r.TryDecodeAsNil() {
					yyv1416[yyj1416] = ConfigMap{}
				} else {
					yyv1419 := &yyv1416[yyj1416]
					yyv1419.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1416 < len(yyv1416) {
			yyv1416 = yyv1416[:yyj1416]
			yyc1416 = true
		} else if yyj1416 == 0 && yyv1416 == nil {
			yyv1416 = []ConfigMap{}
			yyc1416 = true
		}
	}
	yyh1416.End()
	if yyc1416 {
		*v = yyv1416
	}
}

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 _, yyv1420 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1421 := &yyv1420
		yy1421.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

	yyv1422 := *v
	yyh1422, yyl1422 := z.DecSliceHelperStart()
	var yyc1422 bool
	if yyl1422 == 0 {
		if yyv1422 == nil {
			yyv1422 = []ReplicaSet{}
			yyc1422 = true
		} else if len(yyv1422) != 0 {
			yyv1422 = yyv1422[:0]
			yyc1422 = true
		}
	} else if yyl1422 > 0 {
		var yyrr1422, yyrl1422 int
		var yyrt1422 bool
		if yyl1422 > cap(yyv1422) {

			yyrg1422 := len(yyv1422) > 0
			yyv21422 := yyv1422
			yyrl1422, yyrt1422 = z.DecInferLen(yyl1422, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1422 {
				if yyrl1422 <= cap(yyv1422) {
					yyv1422 = yyv1422[:yyrl1422]
				} else {
					yyv1422 = make([]ReplicaSet, yyrl1422)
				}
			} else {
				yyv1422 = make([]ReplicaSet, yyrl1422)
			}
			yyc1422 = true
			yyrr1422 = len(yyv1422)
			if yyrg1422 {
				copy(yyv1422, yyv21422)
			}
		} else if yyl1422 != len(yyv1422) {
			yyv1422 = yyv1422[:yyl1422]
			yyc1422 = true
		}
		yyj1422 := 0
		for ; yyj1422 < yyrr1422; yyj1422++ {
			yyh1422.ElemContainerState(yyj1422)
			if r.TryDecodeAsNil() {
				yyv1422[yyj1422] = ReplicaSet{}
			} else {
				yyv1423 := &yyv1422[yyj1422]
				yyv1423.CodecDecodeSelf(d)
			}

		}
		if yyrt1422 {
			for ; yyj1422 < yyl1422; yyj1422++ {
				yyv1422 = append(yyv1422, ReplicaSet{})
				yyh1422.ElemContainerState(yyj1422)
				if r.TryDecodeAsNil() {
					yyv1422[yyj1422] = ReplicaSet{}
				} else {
					yyv1424 := &yyv1422[yyj1422]
					yyv1424.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1422 >= len(yyv1422) {
				yyv1422 = append(yyv1422, ReplicaSet{}) // var yyz1422 ReplicaSet
				yyc1422 = true
			}
			yyh1422.ElemContainerState(yyj1422)
			if yyj1422 < len(yyv1422) {
				if r.TryDecodeAsNil() {
					yyv1422[yyj1422] = ReplicaSet{}
				} else {
					yyv1425 := &yyv1422[yyj1422]
					yyv1425.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1422 < len(yyv1422) {
			yyv1422 = yyv1422[:yyj1422]
			yyc1422 = true
		} else if yyj1422 == 0 && yyv1422 == nil {
			yyv1422 = []ReplicaSet{}
			yyc1422 = true
		}
	}
	yyh1422.End()
	if yyc1422 {
		*v = yyv1422
	}
}
