types.generated.go

/*
Copyright 2015 The Kubernetes Authors All rights reserved.

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

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

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

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

package v1beta1

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

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

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

type codecSelfer1234 struct{}

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

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

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

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

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

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

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

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

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

func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym30 := z.EncBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep31 := !z.EncBinary()
			yy2arr31 := z.EncBasicHandle().StructToArray
			var yyq31 [5]bool
			_, _, _ = yysep31, yyq31, yy2arr31
			const yyr31 bool = false
			yyq31[0] = true
			yyq31[1] = true
			yyq31[2] = true
			yyq31[3] = x.Kind != ""
			yyq31[4] = x.APIVersion != ""
			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] {
					yy33 := &x.ObjectMeta
					yy33.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy34 := &x.ObjectMeta
					yy34.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[1] {
					yy36 := &x.Spec
					yy36.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy37 := &x.Spec
					yy37.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[2] {
					yy39 := &x.Status
					yy39.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy40 := &x.Status
					yy40.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[3] {
					yym42 := z.EncBinary()
					_ = yym42
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym43 := z.EncBinary()
					_ = yym43
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[4] {
					yym45 := z.EncBinary()
					_ = yym45
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym46 := z.EncBinary()
					_ = yym46
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			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 "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv50 := &x.ObjectMeta
				yyv50.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv51 := &x.Spec
				yyv51.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv52 := &x.Status
				yyv52.CodecDecodeSelf(d)
			}
		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, 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.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv56 := &x.ObjectMeta
		yyv56.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 {
		yyv57 := &x.Spec
		yyv57.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 {
		yyv58 := &x.Status
		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.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())
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj55-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

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

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

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

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

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

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

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

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

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

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

func (x *CustomMetricTarget) 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 [2]bool
			_, _, _ = yysep115, yyq115, yy2arr115
			const yyr115 bool = false
			var yynn115 int
			if yyr115 || yy2arr115 {
				r.EncodeArrayStart(2)
			} else {
				yynn115 = 2
				for _, b := range yyq115 {
					if b {
						yynn115++
					}
				}
				r.EncodeMapStart(yynn115)
				yynn115 = 0
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym117 := z.EncBinary()
				_ = yym117
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym118 := z.EncBinary()
				_ = yym118
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy120 := &x.TargetValue
				yym121 := z.EncBinary()
				_ = yym121
				if false {
				} else if z.HasExtensions() && z.EncExt(yy120) {
				} else if !yym121 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy120)
				} else {
					z.EncFallback(yy120)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy122 := &x.TargetValue
				yym123 := z.EncBinary()
				_ = yym123
				if false {
				} else if z.HasExtensions() && z.EncExt(yy122) {
				} else if !yym123 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy122)
				} else {
					z.EncFallback(yy122)
				}
			}
			if yyr115 || yy2arr115 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys126Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys126Slc
	var yyhl126 bool = l >= 0
	for yyj126 := 0; ; yyj126++ {
		if yyhl126 {
			if yyj126 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys126Slc = r.DecodeBytes(yys126Slc, true, true)
		yys126 := string(yys126Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys126 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.TargetValue = pkg4_resource.Quantity{}
			} else {
				yyv128 := &x.TargetValue
				yym129 := z.DecBinary()
				_ = yym129
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv128) {
				} else if !yym129 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv128)
				} else {
					z.DecFallback(yyv128, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys126)
		} // end switch yys126
	} // end for yyj126
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj130 int
	var yyb130 bool
	var yyhl130 bool = l >= 0
	yyj130++
	if yyhl130 {
		yyb130 = yyj130 > l
	} else {
		yyb130 = r.CheckBreak()
	}
	if yyb130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj130++
	if yyhl130 {
		yyb130 = yyj130 > l
	} else {
		yyb130 = r.CheckBreak()
	}
	if yyb130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetValue = pkg4_resource.Quantity{}
	} else {
		yyv132 := &x.TargetValue
		yym133 := z.DecBinary()
		_ = yym133
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv132) {
		} else if !yym133 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv132)
		} else {
			z.DecFallback(yyv132, false)
		}
	}
	for {
		yyj130++
		if yyhl130 {
			yyb130 = yyj130 > l
		} else {
			yyb130 = r.CheckBreak()
		}
		if yyb130 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj130-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym134 := z.EncBinary()
		_ = yym134
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep135 := !z.EncBinary()
			yy2arr135 := z.EncBasicHandle().StructToArray
			var yyq135 [1]bool
			_, _, _ = yysep135, yyq135, yy2arr135
			const yyr135 bool = false
			var yynn135 int
			if yyr135 || yy2arr135 {
				r.EncodeArrayStart(1)
			} else {
				yynn135 = 1
				for _, b := range yyq135 {
					if b {
						yynn135++
					}
				}
				r.EncodeMapStart(yynn135)
				yynn135 = 0
			}
			if yyr135 || yy2arr135 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym137 := z.EncBinary()
					_ = yym137
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(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 {
					yym138 := z.EncBinary()
					_ = yym138
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			}
			if yyr135 || yy2arr135 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys141Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys141Slc
	var yyhl141 bool = l >= 0
	for yyj141 := 0; ; yyj141++ {
		if yyhl141 {
			if yyj141 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys141Slc = r.DecodeBytes(yys141Slc, true, true)
		yys141 := string(yys141Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys141 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv142 := &x.Items
				yym143 := z.DecBinary()
				_ = yym143
				if false {
				} else {
					h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv142), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys141)
		} // end switch yys141
	} // end for yyj141
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj144 int
	var yyb144 bool
	var yyhl144 bool = l >= 0
	yyj144++
	if yyhl144 {
		yyb144 = yyj144 > l
	} else {
		yyb144 = r.CheckBreak()
	}
	if yyb144 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv145 := &x.Items
		yym146 := z.DecBinary()
		_ = yym146
		if false {
		} else {
			h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv145), d)
		}
	}
	for {
		yyj144++
		if yyhl144 {
			yyb144 = yyj144 > l
		} else {
			yyb144 = r.CheckBreak()
		}
		if yyb144 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj144-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym147 := z.EncBinary()
		_ = yym147
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep148 := !z.EncBinary()
			yy2arr148 := z.EncBasicHandle().StructToArray
			var yyq148 [2]bool
			_, _, _ = yysep148, yyq148, yy2arr148
			const yyr148 bool = false
			var yynn148 int
			if yyr148 || yy2arr148 {
				r.EncodeArrayStart(2)
			} else {
				yynn148 = 2
				for _, b := range yyq148 {
					if b {
						yynn148++
					}
				}
				r.EncodeMapStart(yynn148)
				yynn148 = 0
			}
			if yyr148 || yy2arr148 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym150 := z.EncBinary()
				_ = yym150
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym151 := z.EncBinary()
				_ = yym151
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr148 || yy2arr148 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy153 := &x.CurrentValue
				yym154 := z.EncBinary()
				_ = yym154
				if false {
				} else if z.HasExtensions() && z.EncExt(yy153) {
				} else if !yym154 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy153)
				} else {
					z.EncFallback(yy153)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy155 := &x.CurrentValue
				yym156 := z.EncBinary()
				_ = yym156
				if false {
				} else if z.HasExtensions() && z.EncExt(yy155) {
				} else if !yym156 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy155)
				} else {
					z.EncFallback(yy155)
				}
			}
			if yyr148 || yy2arr148 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys159Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys159Slc
	var yyhl159 bool = l >= 0
	for yyj159 := 0; ; yyj159++ {
		if yyhl159 {
			if yyj159 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys159Slc = r.DecodeBytes(yys159Slc, true, true)
		yys159 := string(yys159Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys159 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.CurrentValue = pkg4_resource.Quantity{}
			} else {
				yyv161 := &x.CurrentValue
				yym162 := z.DecBinary()
				_ = yym162
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv161) {
				} else if !yym162 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv161)
				} else {
					z.DecFallback(yyv161, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys159)
		} // end switch yys159
	} // end for yyj159
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj163 int
	var yyb163 bool
	var yyhl163 bool = l >= 0
	yyj163++
	if yyhl163 {
		yyb163 = yyj163 > l
	} else {
		yyb163 = r.CheckBreak()
	}
	if yyb163 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj163++
	if yyhl163 {
		yyb163 = yyj163 > l
	} else {
		yyb163 = r.CheckBreak()
	}
	if yyb163 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentValue = pkg4_resource.Quantity{}
	} else {
		yyv165 := &x.CurrentValue
		yym166 := z.DecBinary()
		_ = yym166
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv165) {
		} else if !yym166 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv165)
		} else {
			z.DecFallback(yyv165, false)
		}
	}
	for {
		yyj163++
		if yyhl163 {
			yyb163 = yyj163 > l
		} else {
			yyb163 = r.CheckBreak()
		}
		if yyb163 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj163-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym167 := z.EncBinary()
		_ = yym167
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep168 := !z.EncBinary()
			yy2arr168 := z.EncBasicHandle().StructToArray
			var yyq168 [1]bool
			_, _, _ = yysep168, yyq168, yy2arr168
			const yyr168 bool = false
			var yynn168 int
			if yyr168 || yy2arr168 {
				r.EncodeArrayStart(1)
			} else {
				yynn168 = 1
				for _, b := range yyq168 {
					if b {
						yynn168++
					}
				}
				r.EncodeMapStart(yynn168)
				yynn168 = 0
			}
			if yyr168 || yy2arr168 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym170 := z.EncBinary()
					_ = yym170
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(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 {
					yym171 := z.EncBinary()
					_ = yym171
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			}
			if yyr168 || yy2arr168 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys174Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys174Slc
	var yyhl174 bool = l >= 0
	for yyj174 := 0; ; yyj174++ {
		if yyhl174 {
			if yyj174 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys174Slc = r.DecodeBytes(yys174Slc, true, true)
		yys174 := string(yys174Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys174 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv175 := &x.Items
				yym176 := z.DecBinary()
				_ = yym176
				if false {
				} else {
					h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv175), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys174)
		} // end switch yys174
	} // end for yyj174
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj177 int
	var yyb177 bool
	var yyhl177 bool = l >= 0
	yyj177++
	if yyhl177 {
		yyb177 = yyj177 > l
	} else {
		yyb177 = r.CheckBreak()
	}
	if yyb177 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv178 := &x.Items
		yym179 := z.DecBinary()
		_ = yym179
		if false {
		} else {
			h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv178), d)
		}
	}
	for {
		yyj177++
		if yyhl177 {
			yyb177 = yyj177 > l
		} else {
			yyb177 = r.CheckBreak()
		}
		if yyb177 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj177-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 {
		yym180 := z.EncBinary()
		_ = yym180
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep181 := !z.EncBinary()
			yy2arr181 := z.EncBasicHandle().StructToArray
			var yyq181 [4]bool
			_, _, _ = yysep181, yyq181, yy2arr181
			const yyr181 bool = false
			yyq181[1] = x.MinReplicas != nil
			yyq181[3] = x.CPUUtilization != nil
			var yynn181 int
			if yyr181 || yy2arr181 {
				r.EncodeArrayStart(4)
			} else {
				yynn181 = 2
				for _, b := range yyq181 {
					if b {
						yynn181++
					}
				}
				r.EncodeMapStart(yynn181)
				yynn181 = 0
			}
			if yyr181 || yy2arr181 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy183 := &x.ScaleRef
				yy183.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy184 := &x.ScaleRef
				yy184.CodecEncodeSelf(e)
			}
			if yyr181 || yy2arr181 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq181[1] {
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy186 := *x.MinReplicas
						yym187 := z.EncBinary()
						_ = yym187
						if false {
						} else {
							r.EncodeInt(int64(yy186))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq181[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy188 := *x.MinReplicas
						yym189 := z.EncBinary()
						_ = yym189
						if false {
						} else {
							r.EncodeInt(int64(yy188))
						}
					}
				}
			}
			if yyr181 || yy2arr181 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym191 := z.EncBinary()
				_ = yym191
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym192 := z.EncBinary()
				_ = yym192
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			}
			if yyr181 || yy2arr181 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq181[3] {
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq181[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 yyr181 || yy2arr181 {
				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
	yym194 := z.DecBinary()
	_ = yym194
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct195 := r.ContainerType()
		if yyct195 == codecSelferValueTypeMap1234 {
			yyl195 := r.ReadMapStart()
			if yyl195 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl195, d)
			}
		} else if yyct195 == codecSelferValueTypeArray1234 {
			yyl195 := r.ReadArrayStart()
			if yyl195 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl195, 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 yys196Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys196Slc
	var yyhl196 bool = l >= 0
	for yyj196 := 0; ; yyj196++ {
		if yyhl196 {
			if yyj196 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys196Slc = r.DecodeBytes(yys196Slc, true, true)
		yys196 := string(yys196Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys196 {
		case "scaleRef":
			if r.TryDecodeAsNil() {
				x.ScaleRef = SubresourceReference{}
			} else {
				yyv197 := &x.ScaleRef
				yyv197.CodecDecodeSelf(d)
			}
		case "minReplicas":
			if r.TryDecodeAsNil() {
				if x.MinReplicas != nil {
					x.MinReplicas = nil
				}
			} else {
				if x.MinReplicas == nil {
					x.MinReplicas = new(int32)
				}
				yym199 := z.DecBinary()
				_ = yym199
				if false {
				} else {
					*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int32(r.DecodeInt(32))
			}
		case "cpuUtilization":
			if r.TryDecodeAsNil() {
				if x.CPUUtilization != nil {
					x.CPUUtilization = nil
				}
			} else {
				if x.CPUUtilization == nil {
					x.CPUUtilization = new(CPUTargetUtilization)
				}
				x.CPUUtilization.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys196)
		} // end switch yys196
	} // end for yyj196
	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 yyj202 int
	var yyb202 bool
	var yyhl202 bool = l >= 0
	yyj202++
	if yyhl202 {
		yyb202 = yyj202 > l
	} else {
		yyb202 = r.CheckBreak()
	}
	if yyb202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ScaleRef = SubresourceReference{}
	} else {
		yyv203 := &x.ScaleRef
		yyv203.CodecDecodeSelf(d)
	}
	yyj202++
	if yyhl202 {
		yyb202 = yyj202 > l
	} else {
		yyb202 = r.CheckBreak()
	}
	if yyb202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MinReplicas != nil {
			x.MinReplicas = nil
		}
	} else {
		if x.MinReplicas == nil {
			x.MinReplicas = new(int32)
		}
		yym205 := z.DecBinary()
		_ = yym205
		if false {
		} else {
			*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj202++
	if yyhl202 {
		yyb202 = yyj202 > l
	} else {
		yyb202 = r.CheckBreak()
	}
	if yyb202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxReplicas = 0
	} else {
		x.MaxReplicas = int32(r.DecodeInt(32))
	}
	yyj202++
	if yyhl202 {
		yyb202 = yyj202 > l
	} else {
		yyb202 = r.CheckBreak()
	}
	if yyb202 {
		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 {
		yyj202++
		if yyhl202 {
			yyb202 = yyj202 > l
		} else {
			yyb202 = r.CheckBreak()
		}
		if yyb202 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj202-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 {
		yym208 := z.EncBinary()
		_ = yym208
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep209 := !z.EncBinary()
			yy2arr209 := z.EncBasicHandle().StructToArray
			var yyq209 [5]bool
			_, _, _ = yysep209, yyq209, yy2arr209
			const yyr209 bool = false
			yyq209[0] = x.ObservedGeneration != nil
			yyq209[1] = x.LastScaleTime != nil
			yyq209[4] = x.CurrentCPUUtilizationPercentage != nil
			var yynn209 int
			if yyr209 || yy2arr209 {
				r.EncodeArrayStart(5)
			} else {
				yynn209 = 2
				for _, b := range yyq209 {
					if b {
						yynn209++
					}
				}
				r.EncodeMapStart(yynn209)
				yynn209 = 0
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq209[0] {
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy211 := *x.ObservedGeneration
						yym212 := z.EncBinary()
						_ = yym212
						if false {
						} else {
							r.EncodeInt(int64(yy211))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq209[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy213 := *x.ObservedGeneration
						yym214 := z.EncBinary()
						_ = yym214
						if false {
						} else {
							r.EncodeInt(int64(yy213))
						}
					}
				}
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq209[1] {
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym216 := z.EncBinary()
						_ = yym216
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym216 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym216 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq209[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym217 := z.EncBinary()
						_ = yym217
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym217 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym217 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				}
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym219 := z.EncBinary()
				_ = yym219
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym220 := z.EncBinary()
				_ = yym220
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym222 := z.EncBinary()
				_ = yym222
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym223 := z.EncBinary()
				_ = yym223
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq209[4] {
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy225 := *x.CurrentCPUUtilizationPercentage
						yym226 := z.EncBinary()
						_ = yym226
						if false {
						} else {
							r.EncodeInt(int64(yy225))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq209[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy227 := *x.CurrentCPUUtilizationPercentage
						yym228 := z.EncBinary()
						_ = yym228
						if false {
						} else {
							r.EncodeInt(int64(yy227))
						}
					}
				}
			}
			if yyr209 || yy2arr209 {
				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
	yym229 := z.DecBinary()
	_ = yym229
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct230 := r.ContainerType()
		if yyct230 == codecSelferValueTypeMap1234 {
			yyl230 := r.ReadMapStart()
			if yyl230 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl230, d)
			}
		} else if yyct230 == codecSelferValueTypeArray1234 {
			yyl230 := r.ReadArrayStart()
			if yyl230 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl230, 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 yys231Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys231Slc
	var yyhl231 bool = l >= 0
	for yyj231 := 0; ; yyj231++ {
		if yyhl231 {
			if yyj231 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys231Slc = r.DecodeBytes(yys231Slc, true, true)
		yys231 := string(yys231Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys231 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				if x.ObservedGeneration != nil {
					x.ObservedGeneration = nil
				}
			} else {
				if x.ObservedGeneration == nil {
					x.ObservedGeneration = new(int64)
				}
				yym233 := z.DecBinary()
				_ = yym233
				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)
				}
				yym235 := z.DecBinary()
				_ = yym235
				if false {
				} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
				} else if yym235 {
					z.DecBinaryUnmarshal(x.LastScaleTime)
				} else if !yym235 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.LastScaleTime)
				} else {
					z.DecFallback(x.LastScaleTime, false)
				}
			}
		case "currentReplicas":
			if r.TryDecodeAsNil() {
				x.CurrentReplicas = 0
			} else {
				x.CurrentReplicas = int32(r.DecodeInt(32))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int32(r.DecodeInt(32))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int32)
				}
				yym239 := z.DecBinary()
				_ = yym239
				if false {
				} else {
					*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys231)
		} // end switch yys231
	} // end for yyj231
	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 yyj240 int
	var yyb240 bool
	var yyhl240 bool = l >= 0
	yyj240++
	if yyhl240 {
		yyb240 = yyj240 > l
	} else {
		yyb240 = r.CheckBreak()
	}
	if yyb240 {
		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)
		}
		yym242 := z.DecBinary()
		_ = yym242
		if false {
		} else {
			*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
		}
	}
	yyj240++
	if yyhl240 {
		yyb240 = yyj240 > l
	} else {
		yyb240 = r.CheckBreak()
	}
	if yyb240 {
		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)
		}
		yym244 := z.DecBinary()
		_ = yym244
		if false {
		} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
		} else if yym244 {
			z.DecBinaryUnmarshal(x.LastScaleTime)
		} else if !yym244 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.LastScaleTime)
		} else {
			z.DecFallback(x.LastScaleTime, false)
		}
	}
	yyj240++
	if yyhl240 {
		yyb240 = yyj240 > l
	} else {
		yyb240 = r.CheckBreak()
	}
	if yyb240 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentReplicas = 0
	} else {
		x.CurrentReplicas = int32(r.DecodeInt(32))
	}
	yyj240++
	if yyhl240 {
		yyb240 = yyj240 > l
	} else {
		yyb240 = r.CheckBreak()
	}
	if yyb240 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredReplicas = 0
	} else {
		x.DesiredReplicas = int32(r.DecodeInt(32))
	}
	yyj240++
	if yyhl240 {
		yyb240 = yyj240 > l
	} else {
		yyb240 = r.CheckBreak()
	}
	if yyb240 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CurrentCPUUtilizationPercentage != nil {
			x.CurrentCPUUtilizationPercentage = nil
		}
	} else {
		if x.CurrentCPUUtilizationPercentage == nil {
			x.CurrentCPUUtilizationPercentage = new(int32)
		}
		yym248 := z.DecBinary()
		_ = yym248
		if false {
		} else {
			*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
		}
	}
	for {
		yyj240++
		if yyhl240 {
			yyb240 = yyj240 > l
		} else {
			yyb240 = r.CheckBreak()
		}
		if yyb240 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj240-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 {
		yym249 := z.EncBinary()
		_ = yym249
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep250 := !z.EncBinary()
			yy2arr250 := z.EncBasicHandle().StructToArray
			var yyq250 [5]bool
			_, _, _ = yysep250, yyq250, yy2arr250
			const yyr250 bool = false
			yyq250[0] = true
			yyq250[1] = true
			yyq250[2] = true
			yyq250[3] = x.Kind != ""
			yyq250[4] = x.APIVersion != ""
			var yynn250 int
			if yyr250 || yy2arr250 {
				r.EncodeArrayStart(5)
			} else {
				yynn250 = 0
				for _, b := range yyq250 {
					if b {
						yynn250++
					}
				}
				r.EncodeMapStart(yynn250)
				yynn250 = 0
			}
			if yyr250 || yy2arr250 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq250[0] {
					yy252 := &x.ObjectMeta
					yy252.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq250[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy253 := &x.ObjectMeta
					yy253.CodecEncodeSelf(e)
				}
			}
			if yyr250 || yy2arr250 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq250[1] {
					yy255 := &x.Spec
					yy255.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq250[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy256 := &x.Spec
					yy256.CodecEncodeSelf(e)
				}
			}
			if yyr250 || yy2arr250 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq250[2] {
					yy258 := &x.Status
					yy258.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq250[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy259 := &x.Status
					yy259.CodecEncodeSelf(e)
				}
			}
			if yyr250 || yy2arr250 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq250[3] {
					yym261 := z.EncBinary()
					_ = yym261
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq250[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym262 := z.EncBinary()
					_ = yym262
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr250 || yy2arr250 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq250[4] {
					yym264 := z.EncBinary()
					_ = yym264
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq250[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym265 := z.EncBinary()
					_ = yym265
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr250 || yy2arr250 {
				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
	yym266 := z.DecBinary()
	_ = yym266
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct267 := r.ContainerType()
		if yyct267 == codecSelferValueTypeMap1234 {
			yyl267 := r.ReadMapStart()
			if yyl267 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl267, d)
			}
		} else if yyct267 == codecSelferValueTypeArray1234 {
			yyl267 := r.ReadArrayStart()
			if yyl267 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl267, 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 yys268Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys268Slc
	var yyhl268 bool = l >= 0
	for yyj268 := 0; ; yyj268++ {
		if yyhl268 {
			if yyj268 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys268Slc = r.DecodeBytes(yys268Slc, true, true)
		yys268 := string(yys268Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys268 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv269 := &x.ObjectMeta
				yyv269.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = HorizontalPodAutoscalerSpec{}
			} else {
				yyv270 := &x.Spec
				yyv270.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = HorizontalPodAutoscalerStatus{}
			} else {
				yyv271 := &x.Status
				yyv271.CodecDecodeSelf(d)
			}
		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, yys268)
		} // end switch yys268
	} // end for yyj268
	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 yyj274 int
	var yyb274 bool
	var yyhl274 bool = l >= 0
	yyj274++
	if yyhl274 {
		yyb274 = yyj274 > l
	} else {
		yyb274 = r.CheckBreak()
	}
	if yyb274 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv275 := &x.ObjectMeta
		yyv275.CodecDecodeSelf(d)
	}
	yyj274++
	if yyhl274 {
		yyb274 = yyj274 > l
	} else {
		yyb274 = r.CheckBreak()
	}
	if yyb274 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = HorizontalPodAutoscalerSpec{}
	} else {
		yyv276 := &x.Spec
		yyv276.CodecDecodeSelf(d)
	}
	yyj274++
	if yyhl274 {
		yyb274 = yyj274 > l
	} else {
		yyb274 = r.CheckBreak()
	}
	if yyb274 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = HorizontalPodAutoscalerStatus{}
	} else {
		yyv277 := &x.Status
		yyv277.CodecDecodeSelf(d)
	}
	yyj274++
	if yyhl274 {
		yyb274 = yyj274 > l
	} else {
		yyb274 = r.CheckBreak()
	}
	if yyb274 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj274++
	if yyhl274 {
		yyb274 = yyj274 > l
	} else {
		yyb274 = r.CheckBreak()
	}
	if yyb274 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj274++
		if yyhl274 {
			yyb274 = yyj274 > l
		} else {
			yyb274 = r.CheckBreak()
		}
		if yyb274 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj274-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 {
		yym280 := z.EncBinary()
		_ = yym280
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep281 := !z.EncBinary()
			yy2arr281 := z.EncBasicHandle().StructToArray
			var yyq281 [4]bool
			_, _, _ = yysep281, yyq281, yy2arr281
			const yyr281 bool = false
			yyq281[0] = true
			yyq281[2] = x.Kind != ""
			yyq281[3] = x.APIVersion != ""
			var yynn281 int
			if yyr281 || yy2arr281 {
				r.EncodeArrayStart(4)
			} else {
				yynn281 = 1
				for _, b := range yyq281 {
					if b {
						yynn281++
					}
				}
				r.EncodeMapStart(yynn281)
				yynn281 = 0
			}
			if yyr281 || yy2arr281 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq281[0] {
					yy283 := &x.ListMeta
					yym284 := z.EncBinary()
					_ = yym284
					if false {
					} else if z.HasExtensions() && z.EncExt(yy283) {
					} else {
						z.EncFallback(yy283)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq281[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy285 := &x.ListMeta
					yym286 := z.EncBinary()
					_ = yym286
					if false {
					} else if z.HasExtensions() && z.EncExt(yy285) {
					} else {
						z.EncFallback(yy285)
					}
				}
			}
			if yyr281 || yy2arr281 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym288 := z.EncBinary()
					_ = yym288
					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 {
					yym289 := z.EncBinary()
					_ = yym289
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr281 || yy2arr281 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq281[2] {
					yym291 := z.EncBinary()
					_ = yym291
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq281[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym292 := z.EncBinary()
					_ = yym292
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr281 || yy2arr281 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq281[3] {
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq281[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym295 := z.EncBinary()
					_ = yym295
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr281 || yy2arr281 {
				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
	yym296 := z.DecBinary()
	_ = yym296
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct297 := r.ContainerType()
		if yyct297 == codecSelferValueTypeMap1234 {
			yyl297 := r.ReadMapStart()
			if yyl297 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl297, d)
			}
		} else if yyct297 == codecSelferValueTypeArray1234 {
			yyl297 := r.ReadArrayStart()
			if yyl297 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl297, 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 yys298Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys298Slc
	var yyhl298 bool = l >= 0
	for yyj298 := 0; ; yyj298++ {
		if yyhl298 {
			if yyj298 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys298Slc = r.DecodeBytes(yys298Slc, true, true)
		yys298 := string(yys298Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys298 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv299 := &x.ListMeta
				yym300 := z.DecBinary()
				_ = yym300
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv299) {
				} else {
					z.DecFallback(yyv299, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv301 := &x.Items
				yym302 := z.DecBinary()
				_ = yym302
				if false {
				} else {
					h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv301), d)
				}
			}
		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, yys298)
		} // end switch yys298
	} // end for yyj298
	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 yyj305 int
	var yyb305 bool
	var yyhl305 bool = l >= 0
	yyj305++
	if yyhl305 {
		yyb305 = yyj305 > l
	} else {
		yyb305 = r.CheckBreak()
	}
	if yyb305 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv306 := &x.ListMeta
		yym307 := z.DecBinary()
		_ = yym307
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv306) {
		} else {
			z.DecFallback(yyv306, false)
		}
	}
	yyj305++
	if yyhl305 {
		yyb305 = yyj305 > l
	} else {
		yyb305 = r.CheckBreak()
	}
	if yyb305 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv308 := &x.Items
		yym309 := z.DecBinary()
		_ = yym309
		if false {
		} else {
			h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv308), d)
		}
	}
	yyj305++
	if yyhl305 {
		yyb305 = yyj305 > l
	} else {
		yyb305 = r.CheckBreak()
	}
	if yyb305 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj305++
	if yyhl305 {
		yyb305 = yyj305 > l
	} else {
		yyb305 = r.CheckBreak()
	}
	if yyb305 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj305++
		if yyhl305 {
			yyb305 = yyj305 > l
		} else {
			yyb305 = r.CheckBreak()
		}
		if yyb305 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj305-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 {
		yym312 := z.EncBinary()
		_ = yym312
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep313 := !z.EncBinary()
			yy2arr313 := z.EncBasicHandle().StructToArray
			var yyq313 [5]bool
			_, _, _ = yysep313, yyq313, yy2arr313
			const yyr313 bool = false
			yyq313[0] = true
			yyq313[1] = x.Description != ""
			yyq313[2] = len(x.Versions) != 0
			yyq313[3] = x.Kind != ""
			yyq313[4] = x.APIVersion != ""
			var yynn313 int
			if yyr313 || yy2arr313 {
				r.EncodeArrayStart(5)
			} else {
				yynn313 = 0
				for _, b := range yyq313 {
					if b {
						yynn313++
					}
				}
				r.EncodeMapStart(yynn313)
				yynn313 = 0
			}
			if yyr313 || yy2arr313 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq313[0] {
					yy315 := &x.ObjectMeta
					yy315.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq313[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy316 := &x.ObjectMeta
					yy316.CodecEncodeSelf(e)
				}
			}
			if yyr313 || yy2arr313 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq313[1] {
					yym318 := z.EncBinary()
					_ = yym318
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq313[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym319 := z.EncBinary()
					_ = yym319
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr313 || yy2arr313 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq313[2] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym321 := z.EncBinary()
						_ = yym321
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq313[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym322 := z.EncBinary()
						_ = yym322
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yyr313 || yy2arr313 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq313[3] {
					yym324 := z.EncBinary()
					_ = yym324
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq313[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym325 := z.EncBinary()
					_ = yym325
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr313 || yy2arr313 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq313[4] {
					yym327 := z.EncBinary()
					_ = yym327
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq313[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym328 := z.EncBinary()
					_ = yym328
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr313 || yy2arr313 {
				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
	yym329 := z.DecBinary()
	_ = yym329
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct330 := r.ContainerType()
		if yyct330 == codecSelferValueTypeMap1234 {
			yyl330 := r.ReadMapStart()
			if yyl330 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl330, d)
			}
		} else if yyct330 == codecSelferValueTypeArray1234 {
			yyl330 := r.ReadArrayStart()
			if yyl330 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl330, 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 yys331Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys331Slc
	var yyhl331 bool = l >= 0
	for yyj331 := 0; ; yyj331++ {
		if yyhl331 {
			if yyj331 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys331Slc = r.DecodeBytes(yys331Slc, true, true)
		yys331 := string(yys331Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys331 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv332 := &x.ObjectMeta
				yyv332.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv334 := &x.Versions
				yym335 := z.DecBinary()
				_ = yym335
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv334), d)
				}
			}
		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, yys331)
		} // end switch yys331
	} // end for yyj331
	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 yyj338 int
	var yyb338 bool
	var yyhl338 bool = l >= 0
	yyj338++
	if yyhl338 {
		yyb338 = yyj338 > l
	} else {
		yyb338 = r.CheckBreak()
	}
	if yyb338 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv339 := &x.ObjectMeta
		yyv339.CodecDecodeSelf(d)
	}
	yyj338++
	if yyhl338 {
		yyb338 = yyj338 > l
	} else {
		yyb338 = r.CheckBreak()
	}
	if yyb338 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj338++
	if yyhl338 {
		yyb338 = yyj338 > l
	} else {
		yyb338 = r.CheckBreak()
	}
	if yyb338 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv341 := &x.Versions
		yym342 := z.DecBinary()
		_ = yym342
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv341), d)
		}
	}
	yyj338++
	if yyhl338 {
		yyb338 = yyj338 > l
	} else {
		yyb338 = r.CheckBreak()
	}
	if yyb338 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj338++
	if yyhl338 {
		yyb338 = yyj338 > l
	} else {
		yyb338 = r.CheckBreak()
	}
	if yyb338 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj338++
		if yyhl338 {
			yyb338 = yyj338 > l
		} else {
			yyb338 = r.CheckBreak()
		}
		if yyb338 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj338-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 {
		yym345 := z.EncBinary()
		_ = yym345
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep346 := !z.EncBinary()
			yy2arr346 := z.EncBasicHandle().StructToArray
			var yyq346 [4]bool
			_, _, _ = yysep346, yyq346, yy2arr346
			const yyr346 bool = false
			yyq346[0] = true
			yyq346[2] = x.Kind != ""
			yyq346[3] = x.APIVersion != ""
			var yynn346 int
			if yyr346 || yy2arr346 {
				r.EncodeArrayStart(4)
			} else {
				yynn346 = 1
				for _, b := range yyq346 {
					if b {
						yynn346++
					}
				}
				r.EncodeMapStart(yynn346)
				yynn346 = 0
			}
			if yyr346 || yy2arr346 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq346[0] {
					yy348 := &x.ListMeta
					yym349 := z.EncBinary()
					_ = yym349
					if false {
					} else if z.HasExtensions() && z.EncExt(yy348) {
					} else {
						z.EncFallback(yy348)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq346[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy350 := &x.ListMeta
					yym351 := z.EncBinary()
					_ = yym351
					if false {
					} else if z.HasExtensions() && z.EncExt(yy350) {
					} else {
						z.EncFallback(yy350)
					}
				}
			}
			if yyr346 || yy2arr346 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym353 := z.EncBinary()
					_ = yym353
					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 {
					yym354 := z.EncBinary()
					_ = yym354
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yyr346 || yy2arr346 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq346[2] {
					yym356 := z.EncBinary()
					_ = yym356
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq346[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym357 := z.EncBinary()
					_ = yym357
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr346 || yy2arr346 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq346[3] {
					yym359 := z.EncBinary()
					_ = yym359
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq346[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym360 := z.EncBinary()
					_ = yym360
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr346 || yy2arr346 {
				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
	yym361 := z.DecBinary()
	_ = yym361
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct362 := r.ContainerType()
		if yyct362 == codecSelferValueTypeMap1234 {
			yyl362 := r.ReadMapStart()
			if yyl362 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl362, d)
			}
		} else if yyct362 == codecSelferValueTypeArray1234 {
			yyl362 := r.ReadArrayStart()
			if yyl362 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl362, 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 yys363Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys363Slc
	var yyhl363 bool = l >= 0
	for yyj363 := 0; ; yyj363++ {
		if yyhl363 {
			if yyj363 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys363Slc = r.DecodeBytes(yys363Slc, true, true)
		yys363 := string(yys363Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys363 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv364 := &x.ListMeta
				yym365 := z.DecBinary()
				_ = yym365
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv364) {
				} else {
					z.DecFallback(yyv364, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv366 := &x.Items
				yym367 := z.DecBinary()
				_ = yym367
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv366), d)
				}
			}
		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, yys363)
		} // end switch yys363
	} // end for yyj363
	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 yyj370 int
	var yyb370 bool
	var yyhl370 bool = l >= 0
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv371 := &x.ListMeta
		yym372 := z.DecBinary()
		_ = yym372
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv371) {
		} else {
			z.DecFallback(yyv371, false)
		}
	}
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv373 := &x.Items
		yym374 := z.DecBinary()
		_ = yym374
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv373), d)
		}
	}
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj370++
		if yyhl370 {
			yyb370 = yyj370 > l
		} else {
			yyb370 = r.CheckBreak()
		}
		if yyb370 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj370-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 {
		yym377 := z.EncBinary()
		_ = yym377
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep378 := !z.EncBinary()
			yy2arr378 := z.EncBasicHandle().StructToArray
			var yyq378 [2]bool
			_, _, _ = yysep378, yyq378, yy2arr378
			const yyr378 bool = false
			yyq378[0] = x.Name != ""
			yyq378[1] = x.APIGroup != ""
			var yynn378 int
			if yyr378 || yy2arr378 {
				r.EncodeArrayStart(2)
			} else {
				yynn378 = 0
				for _, b := range yyq378 {
					if b {
						yynn378++
					}
				}
				r.EncodeMapStart(yynn378)
				yynn378 = 0
			}
			if yyr378 || yy2arr378 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq378[0] {
					yym380 := z.EncBinary()
					_ = yym380
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq378[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym381 := z.EncBinary()
					_ = yym381
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr378 || yy2arr378 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq378[1] {
					yym383 := z.EncBinary()
					_ = yym383
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq378[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym384 := z.EncBinary()
					_ = yym384
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				}
			}
			if yyr378 || yy2arr378 {
				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
	yym385 := z.DecBinary()
	_ = yym385
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct386 := r.ContainerType()
		if yyct386 == codecSelferValueTypeMap1234 {
			yyl386 := r.ReadMapStart()
			if yyl386 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl386, d)
			}
		} else if yyct386 == codecSelferValueTypeArray1234 {
			yyl386 := r.ReadArrayStart()
			if yyl386 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl386, 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 yys387Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys387Slc
	var yyhl387 bool = l >= 0
	for yyj387 := 0; ; yyj387++ {
		if yyhl387 {
			if yyj387 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys387Slc = r.DecodeBytes(yys387Slc, true, true)
		yys387 := string(yys387Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys387 {
		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, yys387)
		} // end switch yys387
	} // end for yyj387
	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 yyj390 int
	var yyb390 bool
	var yyhl390 bool = l >= 0
	yyj390++
	if yyhl390 {
		yyb390 = yyj390 > l
	} else {
		yyb390 = r.CheckBreak()
	}
	if yyb390 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj390++
	if yyhl390 {
		yyb390 = yyj390 > l
	} else {
		yyb390 = r.CheckBreak()
	}
	if yyb390 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIGroup = ""
	} else {
		x.APIGroup = string(r.DecodeString())
	}
	for {
		yyj390++
		if yyhl390 {
			yyb390 = yyj390 > l
		} else {
			yyb390 = r.CheckBreak()
		}
		if yyb390 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj390-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 {
		yym393 := z.EncBinary()
		_ = yym393
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep394 := !z.EncBinary()
			yy2arr394 := z.EncBasicHandle().StructToArray
			var yyq394 [4]bool
			_, _, _ = yysep394, yyq394, yy2arr394
			const yyr394 bool = false
			yyq394[0] = true
			yyq394[1] = len(x.Data) != 0
			yyq394[2] = x.Kind != ""
			yyq394[3] = x.APIVersion != ""
			var yynn394 int
			if yyr394 || yy2arr394 {
				r.EncodeArrayStart(4)
			} else {
				yynn394 = 0
				for _, b := range yyq394 {
					if b {
						yynn394++
					}
				}
				r.EncodeMapStart(yynn394)
				yynn394 = 0
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[0] {
					yy396 := &x.ObjectMeta
					yy396.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq394[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy397 := &x.ObjectMeta
					yy397.CodecEncodeSelf(e)
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[1] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym399 := z.EncBinary()
						_ = yym399
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq394[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym400 := z.EncBinary()
						_ = yym400
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[2] {
					yym402 := z.EncBinary()
					_ = yym402
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq394[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym403 := z.EncBinary()
					_ = yym403
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[3] {
					yym405 := z.EncBinary()
					_ = yym405
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq394[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym406 := z.EncBinary()
					_ = yym406
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr394 || yy2arr394 {
				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
	yym407 := z.DecBinary()
	_ = yym407
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct408 := r.ContainerType()
		if yyct408 == codecSelferValueTypeMap1234 {
			yyl408 := r.ReadMapStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl408, d)
			}
		} else if yyct408 == codecSelferValueTypeArray1234 {
			yyl408 := r.ReadArrayStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl408, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys409Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys409Slc
	var yyhl409 bool = l >= 0
	for yyj409 := 0; ; yyj409++ {
		if yyhl409 {
			if yyj409 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys409Slc = r.DecodeBytes(yys409Slc, true, true)
		yys409 := string(yys409Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys409 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv410 := &x.ObjectMeta
				yyv410.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv411 := &x.Data
				yym412 := z.DecBinary()
				_ = yym412
				if false {
				} else {
					*yyv411 = r.DecodeBytes(*(*[]byte)(yyv411), false, false)
				}
			}
		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, yys409)
		} // end switch yys409
	} // end for yyj409
	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 yyj415 int
	var yyb415 bool
	var yyhl415 bool = l >= 0
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv416 := &x.ObjectMeta
		yyv416.CodecDecodeSelf(d)
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv417 := &x.Data
		yym418 := z.DecBinary()
		_ = yym418
		if false {
		} else {
			*yyv417 = r.DecodeBytes(*(*[]byte)(yyv417), false, false)
		}
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj415++
		if yyhl415 {
			yyb415 = yyj415 > l
		} else {
			yyb415 = r.CheckBreak()
		}
		if yyb415 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj415-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 {
		yym421 := z.EncBinary()
		_ = yym421
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep422 := !z.EncBinary()
			yy2arr422 := z.EncBasicHandle().StructToArray
			var yyq422 [5]bool
			_, _, _ = yysep422, yyq422, yy2arr422
			const yyr422 bool = false
			yyq422[0] = true
			yyq422[1] = true
			yyq422[2] = true
			yyq422[3] = x.Kind != ""
			yyq422[4] = x.APIVersion != ""
			var yynn422 int
			if yyr422 || yy2arr422 {
				r.EncodeArrayStart(5)
			} else {
				yynn422 = 0
				for _, b := range yyq422 {
					if b {
						yynn422++
					}
				}
				r.EncodeMapStart(yynn422)
				yynn422 = 0
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[0] {
					yy424 := &x.ObjectMeta
					yy424.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy425 := &x.ObjectMeta
					yy425.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[1] {
					yy427 := &x.Spec
					yy427.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy428 := &x.Spec
					yy428.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[2] {
					yy430 := &x.Status
					yy430.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy431 := &x.Status
					yy431.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[3] {
					yym433 := z.EncBinary()
					_ = yym433
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq422[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym434 := z.EncBinary()
					_ = yym434
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[4] {
					yym436 := z.EncBinary()
					_ = yym436
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq422[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym437 := z.EncBinary()
					_ = yym437
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr422 || yy2arr422 {
				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
	yym438 := z.DecBinary()
	_ = yym438
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct439 := r.ContainerType()
		if yyct439 == codecSelferValueTypeMap1234 {
			yyl439 := r.ReadMapStart()
			if yyl439 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl439, d)
			}
		} else if yyct439 == codecSelferValueTypeArray1234 {
			yyl439 := r.ReadArrayStart()
			if yyl439 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl439, 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 yys440Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys440Slc
	var yyhl440 bool = l >= 0
	for yyj440 := 0; ; yyj440++ {
		if yyhl440 {
			if yyj440 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys440Slc = r.DecodeBytes(yys440Slc, true, true)
		yys440 := string(yys440Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys440 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv441 := &x.ObjectMeta
				yyv441.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv442 := &x.Spec
				yyv442.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv443 := &x.Status
				yyv443.CodecDecodeSelf(d)
			}
		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, yys440)
		} // end switch yys440
	} // end for yyj440
	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 yyj446 int
	var yyb446 bool
	var yyhl446 bool = l >= 0
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv447 := &x.ObjectMeta
		yyv447.CodecDecodeSelf(d)
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv448 := &x.Spec
		yyv448.CodecDecodeSelf(d)
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv449 := &x.Status
		yyv449.CodecDecodeSelf(d)
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj446++
		if yyhl446 {
			yyb446 = yyj446 > l
		} else {
			yyb446 = r.CheckBreak()
		}
		if yyb446 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj446-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 {
		yym452 := z.EncBinary()
		_ = yym452
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep453 := !z.EncBinary()
			yy2arr453 := z.EncBasicHandle().StructToArray
			var yyq453 [8]bool
			_, _, _ = yysep453, yyq453, yy2arr453
			const yyr453 bool = false
			yyq453[0] = x.Replicas != nil
			yyq453[1] = x.Selector != nil
			yyq453[3] = true
			yyq453[4] = x.MinReadySeconds != 0
			yyq453[5] = x.RevisionHistoryLimit != nil
			yyq453[6] = x.Paused != false
			yyq453[7] = x.RollbackTo != nil
			var yynn453 int
			if yyr453 || yy2arr453 {
				r.EncodeArrayStart(8)
			} else {
				yynn453 = 1
				for _, b := range yyq453 {
					if b {
						yynn453++
					}
				}
				r.EncodeMapStart(yynn453)
				yynn453 = 0
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy455 := *x.Replicas
						yym456 := z.EncBinary()
						_ = yym456
						if false {
						} else {
							r.EncodeInt(int64(yy455))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy457 := *x.Replicas
						yym458 := z.EncBinary()
						_ = yym458
						if false {
						} else {
							r.EncodeInt(int64(yy457))
						}
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[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 yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy461 := &x.Template
				yy461.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy462 := &x.Template
				yy462.CodecEncodeSelf(e)
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[3] {
					yy464 := &x.Strategy
					yy464.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy465 := &x.Strategy
					yy465.CodecEncodeSelf(e)
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[4] {
					yym467 := z.EncBinary()
					_ = yym467
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq453[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym468 := z.EncBinary()
					_ = yym468
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[5] {
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy470 := *x.RevisionHistoryLimit
						yym471 := z.EncBinary()
						_ = yym471
						if false {
						} else {
							r.EncodeInt(int64(yy470))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy472 := *x.RevisionHistoryLimit
						yym473 := z.EncBinary()
						_ = yym473
						if false {
						} else {
							r.EncodeInt(int64(yy472))
						}
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[6] {
					yym475 := z.EncBinary()
					_ = yym475
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq453[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("paused"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym476 := z.EncBinary()
					_ = yym476
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[7] {
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				}
			}
			if yyr453 || yy2arr453 {
				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
	yym478 := z.DecBinary()
	_ = yym478
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct479 := r.ContainerType()
		if yyct479 == codecSelferValueTypeMap1234 {
			yyl479 := r.ReadMapStart()
			if yyl479 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl479, d)
			}
		} else if yyct479 == codecSelferValueTypeArray1234 {
			yyl479 := r.ReadArrayStart()
			if yyl479 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl479, 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 yys480Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys480Slc
	var yyhl480 bool = l >= 0
	for yyj480 := 0; ; yyj480++ {
		if yyhl480 {
			if yyj480 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys480Slc = r.DecodeBytes(yys480Slc, true, true)
		yys480 := string(yys480Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys480 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym482 := z.DecBinary()
				_ = yym482
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv484 := &x.Template
				yyv484.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv485 := &x.Strategy
				yyv485.CodecDecodeSelf(d)
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		case "revisionHistoryLimit":
			if r.TryDecodeAsNil() {
				if x.RevisionHistoryLimit != nil {
					x.RevisionHistoryLimit = nil
				}
			} else {
				if x.RevisionHistoryLimit == nil {
					x.RevisionHistoryLimit = new(int32)
				}
				yym488 := z.DecBinary()
				_ = yym488
				if false {
				} else {
					*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
				}
			}
		case "paused":
			if r.TryDecodeAsNil() {
				x.Paused = false
			} else {
				x.Paused = bool(r.DecodeBool())
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				if x.RollbackTo != nil {
					x.RollbackTo = nil
				}
			} else {
				if x.RollbackTo == nil {
					x.RollbackTo = new(RollbackConfig)
				}
				x.RollbackTo.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys480)
		} // end switch yys480
	} // end for yyj480
	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 yyj491 int
	var yyb491 bool
	var yyhl491 bool = l >= 0
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym493 := z.DecBinary()
		_ = yym493
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		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)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv495 := &x.Template
		yyv495.CodecDecodeSelf(d)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv496 := &x.Strategy
		yyv496.CodecDecodeSelf(d)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RevisionHistoryLimit != nil {
			x.RevisionHistoryLimit = nil
		}
	} else {
		if x.RevisionHistoryLimit == nil {
			x.RevisionHistoryLimit = new(int32)
		}
		yym499 := z.DecBinary()
		_ = yym499
		if false {
		} else {
			*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
		}
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paused = false
	} else {
		x.Paused = bool(r.DecodeBool())
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollbackTo != nil {
			x.RollbackTo = nil
		}
	} else {
		if x.RollbackTo == nil {
			x.RollbackTo = new(RollbackConfig)
		}
		x.RollbackTo.CodecDecodeSelf(d)
	}
	for {
		yyj491++
		if yyhl491 {
			yyb491 = yyj491 > l
		} else {
			yyb491 = r.CheckBreak()
		}
		if yyb491 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj491-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym502 := z.EncBinary()
		_ = yym502
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep503 := !z.EncBinary()
			yy2arr503 := z.EncBasicHandle().StructToArray
			var yyq503 [5]bool
			_, _, _ = yysep503, yyq503, yy2arr503
			const yyr503 bool = false
			yyq503[1] = len(x.UpdatedAnnotations) != 0
			yyq503[3] = x.Kind != ""
			yyq503[4] = x.APIVersion != ""
			var yynn503 int
			if yyr503 || yy2arr503 {
				r.EncodeArrayStart(5)
			} else {
				yynn503 = 2
				for _, b := range yyq503 {
					if b {
						yynn503++
					}
				}
				r.EncodeMapStart(yynn503)
				yynn503 = 0
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym505 := z.EncBinary()
				_ = yym505
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym506 := z.EncBinary()
				_ = yym506
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[1] {
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym508 := z.EncBinary()
						_ = yym508
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq503[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym509 := z.EncBinary()
						_ = yym509
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy511 := &x.RollbackTo
				yy511.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy512 := &x.RollbackTo
				yy512.CodecEncodeSelf(e)
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[3] {
					yym514 := z.EncBinary()
					_ = yym514
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq503[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym515 := z.EncBinary()
					_ = yym515
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[4] {
					yym517 := z.EncBinary()
					_ = yym517
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq503[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym518 := z.EncBinary()
					_ = yym518
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys521Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys521Slc
	var yyhl521 bool = l >= 0
	for yyj521 := 0; ; yyj521++ {
		if yyhl521 {
			if yyj521 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys521Slc = r.DecodeBytes(yys521Slc, true, true)
		yys521 := string(yys521Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys521 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "updatedAnnotations":
			if r.TryDecodeAsNil() {
				x.UpdatedAnnotations = nil
			} else {
				yyv523 := &x.UpdatedAnnotations
				yym524 := z.DecBinary()
				_ = yym524
				if false {
				} else {
					z.F.DecMapStringStringX(yyv523, false, d)
				}
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				x.RollbackTo = RollbackConfig{}
			} else {
				yyv525 := &x.RollbackTo
				yyv525.CodecDecodeSelf(d)
			}
		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, yys521)
		} // end switch yys521
	} // end for yyj521
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentRollback) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj528 int
	var yyb528 bool
	var yyhl528 bool = l >= 0
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedAnnotations = nil
	} else {
		yyv530 := &x.UpdatedAnnotations
		yym531 := z.DecBinary()
		_ = yym531
		if false {
		} else {
			z.F.DecMapStringStringX(yyv530, false, d)
		}
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RollbackTo = RollbackConfig{}
	} else {
		yyv532 := &x.RollbackTo
		yyv532.CodecDecodeSelf(d)
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj528++
		if yyhl528 {
			yyb528 = yyj528 > l
		} else {
			yyb528 = r.CheckBreak()
		}
		if yyb528 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj528-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym535 := z.EncBinary()
		_ = yym535
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep536 := !z.EncBinary()
			yy2arr536 := z.EncBasicHandle().StructToArray
			var yyq536 [1]bool
			_, _, _ = yysep536, yyq536, yy2arr536
			const yyr536 bool = false
			yyq536[0] = x.Revision != 0
			var yynn536 int
			if yyr536 || yy2arr536 {
				r.EncodeArrayStart(1)
			} else {
				yynn536 = 0
				for _, b := range yyq536 {
					if b {
						yynn536++
					}
				}
				r.EncodeMapStart(yynn536)
				yynn536 = 0
			}
			if yyr536 || yy2arr536 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq536[0] {
					yym538 := z.EncBinary()
					_ = yym538
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq536[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revision"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym539 := z.EncBinary()
					_ = yym539
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				}
			}
			if yyr536 || yy2arr536 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys542Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys542Slc
	var yyhl542 bool = l >= 0
	for yyj542 := 0; ; yyj542++ {
		if yyhl542 {
			if yyj542 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys542Slc = r.DecodeBytes(yys542Slc, true, true)
		yys542 := string(yys542Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys542 {
		case "revision":
			if r.TryDecodeAsNil() {
				x.Revision = 0
			} else {
				x.Revision = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys542)
		} // end switch yys542
	} // end for yyj542
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollbackConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj544 int
	var yyb544 bool
	var yyhl544 bool = l >= 0
	yyj544++
	if yyhl544 {
		yyb544 = yyj544 > l
	} else {
		yyb544 = r.CheckBreak()
	}
	if yyb544 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Revision = 0
	} else {
		x.Revision = int64(r.DecodeInt(64))
	}
	for {
		yyj544++
		if yyhl544 {
			yyb544 = yyj544 > l
		} else {
			yyb544 = r.CheckBreak()
		}
		if yyb544 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj544-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 {
		yym546 := z.EncBinary()
		_ = yym546
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep547 := !z.EncBinary()
			yy2arr547 := z.EncBasicHandle().StructToArray
			var yyq547 [2]bool
			_, _, _ = yysep547, yyq547, yy2arr547
			const yyr547 bool = false
			yyq547[0] = x.Type != ""
			yyq547[1] = x.RollingUpdate != nil
			var yynn547 int
			if yyr547 || yy2arr547 {
				r.EncodeArrayStart(2)
			} else {
				yynn547 = 0
				for _, b := range yyq547 {
					if b {
						yynn547++
					}
				}
				r.EncodeMapStart(yynn547)
				yynn547 = 0
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq547[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[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 yyr547 || yy2arr547 {
				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
	yym550 := z.DecBinary()
	_ = yym550
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct551 := r.ContainerType()
		if yyct551 == codecSelferValueTypeMap1234 {
			yyl551 := r.ReadMapStart()
			if yyl551 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl551, d)
			}
		} else if yyct551 == codecSelferValueTypeArray1234 {
			yyl551 := r.ReadArrayStart()
			if yyl551 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl551, 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 yys552Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys552Slc
	var yyhl552 bool = l >= 0
	for yyj552 := 0; ; yyj552++ {
		if yyhl552 {
			if yyj552 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys552Slc = r.DecodeBytes(yys552Slc, true, true)
		yys552 := string(yys552Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys552 {
		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, yys552)
		} // end switch yys552
	} // end for yyj552
	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 yyj555 int
	var yyb555 bool
	var yyhl555 bool = l >= 0
	yyj555++
	if yyhl555 {
		yyb555 = yyj555 > l
	} else {
		yyb555 = r.CheckBreak()
	}
	if yyb555 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj555++
	if yyhl555 {
		yyb555 = yyj555 > l
	} else {
		yyb555 = r.CheckBreak()
	}
	if yyb555 {
		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 {
		yyj555++
		if yyhl555 {
			yyb555 = yyj555 > l
		} else {
			yyb555 = r.CheckBreak()
		}
		if yyb555 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj555-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym558 := z.EncBinary()
	_ = yym558
	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
	yym559 := z.DecBinary()
	_ = yym559
	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 {
		yym560 := z.EncBinary()
		_ = yym560
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep561 := !z.EncBinary()
			yy2arr561 := z.EncBasicHandle().StructToArray
			var yyq561 [2]bool
			_, _, _ = yysep561, yyq561, yy2arr561
			const yyr561 bool = false
			yyq561[0] = x.MaxUnavailable != nil
			yyq561[1] = x.MaxSurge != nil
			var yynn561 int
			if yyr561 || yy2arr561 {
				r.EncodeArrayStart(2)
			} else {
				yynn561 = 0
				for _, b := range yyq561 {
					if b {
						yynn561++
					}
				}
				r.EncodeMapStart(yynn561)
				yynn561 = 0
			}
			if yyr561 || yy2arr561 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq561[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym563 := z.EncBinary()
						_ = yym563
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym563 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq561[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym564 := z.EncBinary()
						_ = yym564
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym564 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr561 || yy2arr561 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq561[1] {
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym566 := z.EncBinary()
						_ = yym566
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym566 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq561[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym567 := z.EncBinary()
						_ = yym567
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym567 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				}
			}
			if yyr561 || yy2arr561 {
				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
	yym568 := z.DecBinary()
	_ = yym568
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct569 := r.ContainerType()
		if yyct569 == codecSelferValueTypeMap1234 {
			yyl569 := r.ReadMapStart()
			if yyl569 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl569, d)
			}
		} else if yyct569 == codecSelferValueTypeArray1234 {
			yyl569 := r.ReadArrayStart()
			if yyl569 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl569, 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 yys570Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys570Slc
	var yyhl570 bool = l >= 0
	for yyj570 := 0; ; yyj570++ {
		if yyhl570 {
			if yyj570 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys570Slc = r.DecodeBytes(yys570Slc, true, true)
		yys570 := string(yys570Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys570 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg6_intstr.IntOrString)
				}
				yym572 := z.DecBinary()
				_ = yym572
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym572 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxUnavailable)
				} else {
					z.DecFallback(x.MaxUnavailable, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				if x.MaxSurge != nil {
					x.MaxSurge = nil
				}
			} else {
				if x.MaxSurge == nil {
					x.MaxSurge = new(pkg6_intstr.IntOrString)
				}
				yym574 := z.DecBinary()
				_ = yym574
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
				} else if !yym574 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxSurge)
				} else {
					z.DecFallback(x.MaxSurge, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys570)
		} // end switch yys570
	} // end for yyj570
	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 yyj575 int
	var yyb575 bool
	var yyhl575 bool = l >= 0
	yyj575++
	if yyhl575 {
		yyb575 = yyj575 > l
	} else {
		yyb575 = r.CheckBreak()
	}
	if yyb575 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_intstr.IntOrString)
		}
		yym577 := z.DecBinary()
		_ = yym577
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym577 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj575++
	if yyhl575 {
		yyb575 = yyj575 > l
	} else {
		yyb575 = r.CheckBreak()
	}
	if yyb575 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg6_intstr.IntOrString)
		}
		yym579 := z.DecBinary()
		_ = yym579
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym579 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	for {
		yyj575++
		if yyhl575 {
			yyb575 = yyj575 > l
		} else {
			yyb575 = r.CheckBreak()
		}
		if yyb575 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj575-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 {
		yym580 := z.EncBinary()
		_ = yym580
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep581 := !z.EncBinary()
			yy2arr581 := z.EncBasicHandle().StructToArray
			var yyq581 [4]bool
			_, _, _ = yysep581, yyq581, yy2arr581
			const yyr581 bool = false
			yyq581[0] = x.Replicas != 0
			yyq581[1] = x.UpdatedReplicas != 0
			yyq581[2] = x.AvailableReplicas != 0
			yyq581[3] = x.UnavailableReplicas != 0
			var yynn581 int
			if yyr581 || yy2arr581 {
				r.EncodeArrayStart(4)
			} else {
				yynn581 = 0
				for _, b := range yyq581 {
					if b {
						yynn581++
					}
				}
				r.EncodeMapStart(yynn581)
				yynn581 = 0
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[0] {
					yym583 := z.EncBinary()
					_ = yym583
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym584 := z.EncBinary()
					_ = yym584
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[1] {
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym587 := z.EncBinary()
					_ = yym587
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[2] {
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[3] {
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				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
	yym594 := z.DecBinary()
	_ = yym594
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct595 := r.ContainerType()
		if yyct595 == codecSelferValueTypeMap1234 {
			yyl595 := r.ReadMapStart()
			if yyl595 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl595, d)
			}
		} else if yyct595 == codecSelferValueTypeArray1234 {
			yyl595 := r.ReadArrayStart()
			if yyl595 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl595, 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 yys596Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys596Slc
	var yyhl596 bool = l >= 0
	for yyj596 := 0; ; yyj596++ {
		if yyhl596 {
			if yyj596 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys596Slc = r.DecodeBytes(yys596Slc, true, true)
		yys596 := string(yys596Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys596 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int32(r.DecodeInt(32))
			}
		case "availableReplicas":
			if r.TryDecodeAsNil() {
				x.AvailableReplicas = 0
			} else {
				x.AvailableReplicas = int32(r.DecodeInt(32))
			}
		case "unavailableReplicas":
			if r.TryDecodeAsNil() {
				x.UnavailableReplicas = 0
			} else {
				x.UnavailableReplicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys596)
		} // end switch yys596
	} // end for yyj596
	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 yyj601 int
	var yyb601 bool
	var yyhl601 bool = l >= 0
	yyj601++
	if yyhl601 {
		yyb601 = yyj601 > l
	} else {
		yyb601 = r.CheckBreak()
	}
	if yyb601 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj601++
	if yyhl601 {
		yyb601 = yyj601 > l
	} else {
		yyb601 = r.CheckBreak()
	}
	if yyb601 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int32(r.DecodeInt(32))
	}
	yyj601++
	if yyhl601 {
		yyb601 = yyj601 > l
	} else {
		yyb601 = r.CheckBreak()
	}
	if yyb601 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj601++
	if yyhl601 {
		yyb601 = yyj601 > l
	} else {
		yyb601 = r.CheckBreak()
	}
	if yyb601 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UnavailableReplicas = 0
	} else {
		x.UnavailableReplicas = int32(r.DecodeInt(32))
	}
	for {
		yyj601++
		if yyhl601 {
			yyb601 = yyj601 > l
		} else {
			yyb601 = r.CheckBreak()
		}
		if yyb601 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj601-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 {
		yym606 := z.EncBinary()
		_ = yym606
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep607 := !z.EncBinary()
			yy2arr607 := z.EncBasicHandle().StructToArray
			var yyq607 [4]bool
			_, _, _ = yysep607, yyq607, yy2arr607
			const yyr607 bool = false
			yyq607[0] = true
			yyq607[2] = x.Kind != ""
			yyq607[3] = x.APIVersion != ""
			var yynn607 int
			if yyr607 || yy2arr607 {
				r.EncodeArrayStart(4)
			} else {
				yynn607 = 1
				for _, b := range yyq607 {
					if b {
						yynn607++
					}
				}
				r.EncodeMapStart(yynn607)
				yynn607 = 0
			}
			if yyr607 || yy2arr607 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq607[0] {
					yy609 := &x.ListMeta
					yym610 := z.EncBinary()
					_ = yym610
					if false {
					} else if z.HasExtensions() && z.EncExt(yy609) {
					} else {
						z.EncFallback(yy609)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq607[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy611 := &x.ListMeta
					yym612 := z.EncBinary()
					_ = yym612
					if false {
					} else if z.HasExtensions() && z.EncExt(yy611) {
					} else {
						z.EncFallback(yy611)
					}
				}
			}
			if yyr607 || yy2arr607 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym614 := z.EncBinary()
					_ = yym614
					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 {
					yym615 := z.EncBinary()
					_ = yym615
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr607 || yy2arr607 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq607[2] {
					yym617 := z.EncBinary()
					_ = yym617
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq607[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr607 || yy2arr607 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq607[3] {
					yym620 := z.EncBinary()
					_ = yym620
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq607[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr607 || yy2arr607 {
				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
	yym622 := z.DecBinary()
	_ = yym622
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct623 := r.ContainerType()
		if yyct623 == codecSelferValueTypeMap1234 {
			yyl623 := r.ReadMapStart()
			if yyl623 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl623, d)
			}
		} else if yyct623 == codecSelferValueTypeArray1234 {
			yyl623 := r.ReadArrayStart()
			if yyl623 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl623, 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 yys624Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys624Slc
	var yyhl624 bool = l >= 0
	for yyj624 := 0; ; yyj624++ {
		if yyhl624 {
			if yyj624 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys624Slc = r.DecodeBytes(yys624Slc, true, true)
		yys624 := string(yys624Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys624 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv625 := &x.ListMeta
				yym626 := z.DecBinary()
				_ = yym626
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv625) {
				} else {
					z.DecFallback(yyv625, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv627 := &x.Items
				yym628 := z.DecBinary()
				_ = yym628
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv627), d)
				}
			}
		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, yys624)
		} // end switch yys624
	} // end for yyj624
	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 yyj631 int
	var yyb631 bool
	var yyhl631 bool = l >= 0
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv632 := &x.ListMeta
		yym633 := z.DecBinary()
		_ = yym633
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv632) {
		} else {
			z.DecFallback(yyv632, false)
		}
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv634 := &x.Items
		yym635 := z.DecBinary()
		_ = yym635
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv634), d)
		}
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj631++
		if yyhl631 {
			yyb631 = yyj631 > l
		} else {
			yyb631 = r.CheckBreak()
		}
		if yyb631 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj631-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 {
		yym638 := z.EncBinary()
		_ = yym638
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep639 := !z.EncBinary()
			yy2arr639 := z.EncBasicHandle().StructToArray
			var yyq639 [2]bool
			_, _, _ = yysep639, yyq639, yy2arr639
			const yyr639 bool = false
			yyq639[0] = x.Type != ""
			yyq639[1] = x.RollingUpdate != nil
			var yynn639 int
			if yyr639 || yy2arr639 {
				r.EncodeArrayStart(2)
			} else {
				yynn639 = 0
				for _, b := range yyq639 {
					if b {
						yynn639++
					}
				}
				r.EncodeMapStart(yynn639)
				yynn639 = 0
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq639[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq639[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr639 || yy2arr639 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq639[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq639[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 yyr639 || yy2arr639 {
				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
	yym642 := z.DecBinary()
	_ = yym642
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct643 := r.ContainerType()
		if yyct643 == codecSelferValueTypeMap1234 {
			yyl643 := r.ReadMapStart()
			if yyl643 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl643, d)
			}
		} else if yyct643 == codecSelferValueTypeArray1234 {
			yyl643 := r.ReadArrayStart()
			if yyl643 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl643, 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 yys644Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys644Slc
	var yyhl644 bool = l >= 0
	for yyj644 := 0; ; yyj644++ {
		if yyhl644 {
			if yyj644 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys644Slc = r.DecodeBytes(yys644Slc, true, true)
		yys644 := string(yys644Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys644 {
		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, yys644)
		} // end switch yys644
	} // end for yyj644
	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 yyj647 int
	var yyb647 bool
	var yyhl647 bool = l >= 0
	yyj647++
	if yyhl647 {
		yyb647 = yyj647 > l
	} else {
		yyb647 = r.CheckBreak()
	}
	if yyb647 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DaemonSetUpdateStrategyType(r.DecodeString())
	}
	yyj647++
	if yyhl647 {
		yyb647 = yyj647 > l
	} else {
		yyb647 = r.CheckBreak()
	}
	if yyb647 {
		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 {
		yyj647++
		if yyhl647 {
			yyb647 = yyj647 > l
		} else {
			yyb647 = r.CheckBreak()
		}
		if yyb647 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj647-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DaemonSetUpdateStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym650 := z.EncBinary()
	_ = yym650
	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
	yym651 := z.DecBinary()
	_ = yym651
	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 {
		yym652 := z.EncBinary()
		_ = yym652
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep653 := !z.EncBinary()
			yy2arr653 := z.EncBasicHandle().StructToArray
			var yyq653 [2]bool
			_, _, _ = yysep653, yyq653, yy2arr653
			const yyr653 bool = false
			yyq653[0] = x.MaxUnavailable != nil
			yyq653[1] = x.MinReadySeconds != 0
			var yynn653 int
			if yyr653 || yy2arr653 {
				r.EncodeArrayStart(2)
			} else {
				yynn653 = 0
				for _, b := range yyq653 {
					if b {
						yynn653++
					}
				}
				r.EncodeMapStart(yynn653)
				yynn653 = 0
			}
			if yyr653 || yy2arr653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq653[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym655 := z.EncBinary()
						_ = yym655
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym655 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq653[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym656 := z.EncBinary()
						_ = yym656
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym656 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr653 || yy2arr653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq653[1] {
					yym658 := z.EncBinary()
					_ = yym658
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq653[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym659 := z.EncBinary()
					_ = yym659
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr653 || yy2arr653 {
				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
	yym660 := z.DecBinary()
	_ = yym660
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct661 := r.ContainerType()
		if yyct661 == codecSelferValueTypeMap1234 {
			yyl661 := r.ReadMapStart()
			if yyl661 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl661, d)
			}
		} else if yyct661 == codecSelferValueTypeArray1234 {
			yyl661 := r.ReadArrayStart()
			if yyl661 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl661, 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 yys662Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys662Slc
	var yyhl662 bool = l >= 0
	for yyj662 := 0; ; yyj662++ {
		if yyhl662 {
			if yyj662 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys662Slc = r.DecodeBytes(yys662Slc, true, true)
		yys662 := string(yys662Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys662 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg6_intstr.IntOrString)
				}
				yym664 := z.DecBinary()
				_ = yym664
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym664 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxUnavailable)
				} else {
					z.DecFallback(x.MaxUnavailable, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys662)
		} // end switch yys662
	} // end for yyj662
	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 yyj666 int
	var yyb666 bool
	var yyhl666 bool = l >= 0
	yyj666++
	if yyhl666 {
		yyb666 = yyj666 > l
	} else {
		yyb666 = r.CheckBreak()
	}
	if yyb666 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_intstr.IntOrString)
		}
		yym668 := z.DecBinary()
		_ = yym668
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym668 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj666++
	if yyhl666 {
		yyb666 = yyj666 > l
	} else {
		yyb666 = r.CheckBreak()
	}
	if yyb666 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	for {
		yyj666++
		if yyhl666 {
			yyb666 = yyj666 > l
		} else {
			yyb666 = r.CheckBreak()
		}
		if yyb666 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj666-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 {
		yym670 := z.EncBinary()
		_ = yym670
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep671 := !z.EncBinary()
			yy2arr671 := z.EncBasicHandle().StructToArray
			var yyq671 [4]bool
			_, _, _ = yysep671, yyq671, yy2arr671
			const yyr671 bool = false
			yyq671[0] = x.Selector != nil
			yyq671[2] = true
			yyq671[3] = x.UniqueLabelKey != nil
			var yynn671 int
			if yyr671 || yy2arr671 {
				r.EncodeArrayStart(4)
			} else {
				yynn671 = 1
				for _, b := range yyq671 {
					if b {
						yynn671++
					}
				}
				r.EncodeMapStart(yynn671)
				yynn671 = 0
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[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 yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy674 := &x.Template
				yy674.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy675 := &x.Template
				yy675.CodecEncodeSelf(e)
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[2] {
					yy677 := &x.UpdateStrategy
					yy677.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updateStrategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy678 := &x.UpdateStrategy
					yy678.CodecEncodeSelf(e)
				}
			}
			if yyr671 || yy2arr671 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq671[3] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy680 := *x.UniqueLabelKey
						yym681 := z.EncBinary()
						_ = yym681
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy680))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq671[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy682 := *x.UniqueLabelKey
						yym683 := z.EncBinary()
						_ = yym683
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy682))
						}
					}
				}
			}
			if yyr671 || yy2arr671 {
				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
	yym684 := z.DecBinary()
	_ = yym684
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct685 := r.ContainerType()
		if yyct685 == codecSelferValueTypeMap1234 {
			yyl685 := r.ReadMapStart()
			if yyl685 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl685, d)
			}
		} else if yyct685 == codecSelferValueTypeArray1234 {
			yyl685 := r.ReadArrayStart()
			if yyl685 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl685, 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 yys686Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys686Slc
	var yyhl686 bool = l >= 0
	for yyj686 := 0; ; yyj686++ {
		if yyhl686 {
			if yyj686 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys686Slc = r.DecodeBytes(yys686Slc, true, true)
		yys686 := string(yys686Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys686 {
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv688 := &x.Template
				yyv688.CodecDecodeSelf(d)
			}
		case "updateStrategy":
			if r.TryDecodeAsNil() {
				x.UpdateStrategy = DaemonSetUpdateStrategy{}
			} else {
				yyv689 := &x.UpdateStrategy
				yyv689.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				if x.UniqueLabelKey != nil {
					x.UniqueLabelKey = nil
				}
			} else {
				if x.UniqueLabelKey == nil {
					x.UniqueLabelKey = new(string)
				}
				yym691 := z.DecBinary()
				_ = yym691
				if false {
				} else {
					*((*string)(x.UniqueLabelKey)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys686)
		} // end switch yys686
	} // end for yyj686
	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 yyj692 int
	var yyb692 bool
	var yyhl692 bool = l >= 0
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		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)
	}
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv694 := &x.Template
		yyv694.CodecDecodeSelf(d)
	}
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdateStrategy = DaemonSetUpdateStrategy{}
	} else {
		yyv695 := &x.UpdateStrategy
		yyv695.CodecDecodeSelf(d)
	}
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym697 := z.DecBinary()
		_ = yym697
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj692++
		if yyhl692 {
			yyb692 = yyj692 > l
		} else {
			yyb692 = r.CheckBreak()
		}
		if yyb692 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj692-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 {
		yym698 := z.EncBinary()
		_ = yym698
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep699 := !z.EncBinary()
			yy2arr699 := z.EncBasicHandle().StructToArray
			var yyq699 [3]bool
			_, _, _ = yysep699, yyq699, yy2arr699
			const yyr699 bool = false
			var yynn699 int
			if yyr699 || yy2arr699 {
				r.EncodeArrayStart(3)
			} else {
				yynn699 = 3
				for _, b := range yyq699 {
					if b {
						yynn699++
					}
				}
				r.EncodeMapStart(yynn699)
				yynn699 = 0
			}
			if yyr699 || yy2arr699 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym701 := z.EncBinary()
				_ = yym701
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym702 := z.EncBinary()
				_ = yym702
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr699 || yy2arr699 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym704 := z.EncBinary()
				_ = yym704
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym705 := z.EncBinary()
				_ = yym705
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr699 || yy2arr699 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym707 := z.EncBinary()
				_ = yym707
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym708 := z.EncBinary()
				_ = yym708
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr699 || yy2arr699 {
				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
	yym709 := z.DecBinary()
	_ = yym709
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct710 := r.ContainerType()
		if yyct710 == codecSelferValueTypeMap1234 {
			yyl710 := r.ReadMapStart()
			if yyl710 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl710, d)
			}
		} else if yyct710 == codecSelferValueTypeArray1234 {
			yyl710 := r.ReadArrayStart()
			if yyl710 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl710, 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 yys711Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys711Slc
	var yyhl711 bool = l >= 0
	for yyj711 := 0; ; yyj711++ {
		if yyhl711 {
			if yyj711 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys711Slc = r.DecodeBytes(yys711Slc, true, true)
		yys711 := string(yys711Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys711 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int32(r.DecodeInt(32))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int32(r.DecodeInt(32))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys711)
		} // end switch yys711
	} // end for yyj711
	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 yyj715 int
	var yyb715 bool
	var yyhl715 bool = l >= 0
	yyj715++
	if yyhl715 {
		yyb715 = yyj715 > l
	} else {
		yyb715 = r.CheckBreak()
	}
	if yyb715 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj715++
	if yyhl715 {
		yyb715 = yyj715 > l
	} else {
		yyb715 = r.CheckBreak()
	}
	if yyb715 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj715++
	if yyhl715 {
		yyb715 = yyj715 > l
	} else {
		yyb715 = r.CheckBreak()
	}
	if yyb715 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	for {
		yyj715++
		if yyhl715 {
			yyb715 = yyj715 > l
		} else {
			yyb715 = r.CheckBreak()
		}
		if yyb715 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj715-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 {
		yym719 := z.EncBinary()
		_ = yym719
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep720 := !z.EncBinary()
			yy2arr720 := z.EncBasicHandle().StructToArray
			var yyq720 [5]bool
			_, _, _ = yysep720, yyq720, yy2arr720
			const yyr720 bool = false
			yyq720[0] = true
			yyq720[1] = true
			yyq720[2] = true
			yyq720[3] = x.Kind != ""
			yyq720[4] = x.APIVersion != ""
			var yynn720 int
			if yyr720 || yy2arr720 {
				r.EncodeArrayStart(5)
			} else {
				yynn720 = 0
				for _, b := range yyq720 {
					if b {
						yynn720++
					}
				}
				r.EncodeMapStart(yynn720)
				yynn720 = 0
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[0] {
					yy722 := &x.ObjectMeta
					yy722.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq720[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy723 := &x.ObjectMeta
					yy723.CodecEncodeSelf(e)
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[1] {
					yy725 := &x.Spec
					yy725.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq720[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy726 := &x.Spec
					yy726.CodecEncodeSelf(e)
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[2] {
					yy728 := &x.Status
					yy728.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq720[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy729 := &x.Status
					yy729.CodecEncodeSelf(e)
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[3] {
					yym731 := z.EncBinary()
					_ = yym731
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq720[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym732 := z.EncBinary()
					_ = yym732
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr720 || yy2arr720 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq720[4] {
					yym734 := z.EncBinary()
					_ = yym734
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq720[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym735 := z.EncBinary()
					_ = yym735
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr720 || yy2arr720 {
				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
	yym736 := z.DecBinary()
	_ = yym736
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct737 := r.ContainerType()
		if yyct737 == codecSelferValueTypeMap1234 {
			yyl737 := r.ReadMapStart()
			if yyl737 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl737, d)
			}
		} else if yyct737 == codecSelferValueTypeArray1234 {
			yyl737 := r.ReadArrayStart()
			if yyl737 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl737, 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 yys738Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys738Slc
	var yyhl738 bool = l >= 0
	for yyj738 := 0; ; yyj738++ {
		if yyhl738 {
			if yyj738 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys738Slc = r.DecodeBytes(yys738Slc, true, true)
		yys738 := string(yys738Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys738 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv739 := &x.ObjectMeta
				yyv739.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv740 := &x.Spec
				yyv740.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv741 := &x.Status
				yyv741.CodecDecodeSelf(d)
			}
		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, yys738)
		} // end switch yys738
	} // end for yyj738
	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 yyj744 int
	var yyb744 bool
	var yyhl744 bool = l >= 0
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv745 := &x.ObjectMeta
		yyv745.CodecDecodeSelf(d)
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv746 := &x.Spec
		yyv746.CodecDecodeSelf(d)
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv747 := &x.Status
		yyv747.CodecDecodeSelf(d)
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj744++
	if yyhl744 {
		yyb744 = yyj744 > l
	} else {
		yyb744 = r.CheckBreak()
	}
	if yyb744 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj744++
		if yyhl744 {
			yyb744 = yyj744 > l
		} else {
			yyb744 = r.CheckBreak()
		}
		if yyb744 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj744-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym750 := z.EncBinary()
		_ = yym750
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep751 := !z.EncBinary()
			yy2arr751 := z.EncBasicHandle().StructToArray
			var yyq751 [4]bool
			_, _, _ = yysep751, yyq751, yy2arr751
			const yyr751 bool = false
			yyq751[0] = true
			yyq751[2] = x.Kind != ""
			yyq751[3] = x.APIVersion != ""
			var yynn751 int
			if yyr751 || yy2arr751 {
				r.EncodeArrayStart(4)
			} else {
				yynn751 = 1
				for _, b := range yyq751 {
					if b {
						yynn751++
					}
				}
				r.EncodeMapStart(yynn751)
				yynn751 = 0
			}
			if yyr751 || yy2arr751 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq751[0] {
					yy753 := &x.ListMeta
					yym754 := z.EncBinary()
					_ = yym754
					if false {
					} else if z.HasExtensions() && z.EncExt(yy753) {
					} else {
						z.EncFallback(yy753)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq751[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy755 := &x.ListMeta
					yym756 := z.EncBinary()
					_ = yym756
					if false {
					} else if z.HasExtensions() && z.EncExt(yy755) {
					} else {
						z.EncFallback(yy755)
					}
				}
			}
			if yyr751 || yy2arr751 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym758 := z.EncBinary()
					_ = yym758
					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 {
					yym759 := z.EncBinary()
					_ = yym759
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr751 || yy2arr751 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq751[2] {
					yym761 := z.EncBinary()
					_ = yym761
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq751[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym762 := z.EncBinary()
					_ = yym762
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr751 || yy2arr751 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq751[3] {
					yym764 := z.EncBinary()
					_ = yym764
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq751[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym765 := z.EncBinary()
					_ = yym765
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr751 || yy2arr751 {
				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
	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 *DaemonSetList) 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 "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv769 := &x.ListMeta
				yym770 := z.DecBinary()
				_ = yym770
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv769) {
				} else {
					z.DecFallback(yyv769, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv771 := &x.Items
				yym772 := z.DecBinary()
				_ = yym772
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv771), d)
				}
			}
		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, yys768)
		} // end switch yys768
	} // end for yyj768
	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 yyj775 int
	var yyb775 bool
	var yyhl775 bool = l >= 0
	yyj775++
	if yyhl775 {
		yyb775 = yyj775 > l
	} else {
		yyb775 = r.CheckBreak()
	}
	if yyb775 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv776 := &x.ListMeta
		yym777 := z.DecBinary()
		_ = yym777
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv776) {
		} else {
			z.DecFallback(yyv776, false)
		}
	}
	yyj775++
	if yyhl775 {
		yyb775 = yyj775 > l
	} else {
		yyb775 = r.CheckBreak()
	}
	if yyb775 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv778 := &x.Items
		yym779 := z.DecBinary()
		_ = yym779
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv778), d)
		}
	}
	yyj775++
	if yyhl775 {
		yyb775 = yyj775 > l
	} else {
		yyb775 = r.CheckBreak()
	}
	if yyb775 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj775++
	if yyhl775 {
		yyb775 = yyj775 > l
	} else {
		yyb775 = r.CheckBreak()
	}
	if yyb775 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj775++
		if yyhl775 {
			yyb775 = yyj775 > l
		} else {
			yyb775 = r.CheckBreak()
		}
		if yyb775 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj775-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 {
		yym782 := z.EncBinary()
		_ = yym782
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep783 := !z.EncBinary()
			yy2arr783 := z.EncBasicHandle().StructToArray
			var yyq783 [4]bool
			_, _, _ = yysep783, yyq783, yy2arr783
			const yyr783 bool = false
			yyq783[0] = true
			yyq783[2] = x.Kind != ""
			yyq783[3] = x.APIVersion != ""
			var yynn783 int
			if yyr783 || yy2arr783 {
				r.EncodeArrayStart(4)
			} else {
				yynn783 = 1
				for _, b := range yyq783 {
					if b {
						yynn783++
					}
				}
				r.EncodeMapStart(yynn783)
				yynn783 = 0
			}
			if yyr783 || yy2arr783 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq783[0] {
					yy785 := &x.ListMeta
					yym786 := z.EncBinary()
					_ = yym786
					if false {
					} else if z.HasExtensions() && z.EncExt(yy785) {
					} else {
						z.EncFallback(yy785)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq783[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy787 := &x.ListMeta
					yym788 := z.EncBinary()
					_ = yym788
					if false {
					} else if z.HasExtensions() && z.EncExt(yy787) {
					} else {
						z.EncFallback(yy787)
					}
				}
			}
			if yyr783 || yy2arr783 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym790 := z.EncBinary()
					_ = yym790
					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 {
					yym791 := z.EncBinary()
					_ = yym791
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr783 || yy2arr783 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq783[2] {
					yym793 := z.EncBinary()
					_ = yym793
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq783[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym794 := z.EncBinary()
					_ = yym794
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr783 || yy2arr783 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq783[3] {
					yym796 := z.EncBinary()
					_ = yym796
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq783[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym797 := z.EncBinary()
					_ = yym797
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr783 || yy2arr783 {
				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
	yym798 := z.DecBinary()
	_ = yym798
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct799 := r.ContainerType()
		if yyct799 == codecSelferValueTypeMap1234 {
			yyl799 := r.ReadMapStart()
			if yyl799 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl799, d)
			}
		} else if yyct799 == codecSelferValueTypeArray1234 {
			yyl799 := r.ReadArrayStart()
			if yyl799 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl799, 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 yys800Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys800Slc
	var yyhl800 bool = l >= 0
	for yyj800 := 0; ; yyj800++ {
		if yyhl800 {
			if yyj800 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys800Slc = r.DecodeBytes(yys800Slc, true, true)
		yys800 := string(yys800Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys800 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv801 := &x.ListMeta
				yym802 := z.DecBinary()
				_ = yym802
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv801) {
				} else {
					z.DecFallback(yyv801, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv803 := &x.Items
				yym804 := z.DecBinary()
				_ = yym804
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv803), d)
				}
			}
		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, yys800)
		} // end switch yys800
	} // end for yyj800
	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 yyj807 int
	var yyb807 bool
	var yyhl807 bool = l >= 0
	yyj807++
	if yyhl807 {
		yyb807 = yyj807 > l
	} else {
		yyb807 = r.CheckBreak()
	}
	if yyb807 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv808 := &x.ListMeta
		yym809 := z.DecBinary()
		_ = yym809
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv808) {
		} else {
			z.DecFallback(yyv808, false)
		}
	}
	yyj807++
	if yyhl807 {
		yyb807 = yyj807 > l
	} else {
		yyb807 = r.CheckBreak()
	}
	if yyb807 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv810 := &x.Items
		yym811 := z.DecBinary()
		_ = yym811
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv810), d)
		}
	}
	yyj807++
	if yyhl807 {
		yyb807 = yyj807 > l
	} else {
		yyb807 = r.CheckBreak()
	}
	if yyb807 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj807++
	if yyhl807 {
		yyb807 = yyj807 > l
	} else {
		yyb807 = r.CheckBreak()
	}
	if yyb807 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj807++
		if yyhl807 {
			yyb807 = yyj807 > l
		} else {
			yyb807 = r.CheckBreak()
		}
		if yyb807 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj807-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 {
		yym814 := z.EncBinary()
		_ = yym814
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep815 := !z.EncBinary()
			yy2arr815 := z.EncBasicHandle().StructToArray
			var yyq815 [5]bool
			_, _, _ = yysep815, yyq815, yy2arr815
			const yyr815 bool = false
			yyq815[0] = true
			yyq815[1] = true
			yyq815[2] = true
			yyq815[3] = x.Kind != ""
			yyq815[4] = x.APIVersion != ""
			var yynn815 int
			if yyr815 || yy2arr815 {
				r.EncodeArrayStart(5)
			} else {
				yynn815 = 0
				for _, b := range yyq815 {
					if b {
						yynn815++
					}
				}
				r.EncodeMapStart(yynn815)
				yynn815 = 0
			}
			if yyr815 || yy2arr815 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq815[0] {
					yy817 := &x.ObjectMeta
					yy817.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq815[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy818 := &x.ObjectMeta
					yy818.CodecEncodeSelf(e)
				}
			}
			if yyr815 || yy2arr815 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq815[1] {
					yy820 := &x.Spec
					yy820.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq815[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy821 := &x.Spec
					yy821.CodecEncodeSelf(e)
				}
			}
			if yyr815 || yy2arr815 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq815[2] {
					yy823 := &x.Status
					yy823.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq815[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy824 := &x.Status
					yy824.CodecEncodeSelf(e)
				}
			}
			if yyr815 || yy2arr815 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq815[3] {
					yym826 := z.EncBinary()
					_ = yym826
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq815[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym827 := z.EncBinary()
					_ = yym827
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr815 || yy2arr815 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq815[4] {
					yym829 := z.EncBinary()
					_ = yym829
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq815[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym830 := z.EncBinary()
					_ = yym830
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr815 || yy2arr815 {
				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
	yym831 := z.DecBinary()
	_ = yym831
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct832 := r.ContainerType()
		if yyct832 == codecSelferValueTypeMap1234 {
			yyl832 := r.ReadMapStart()
			if yyl832 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl832, d)
			}
		} else if yyct832 == codecSelferValueTypeArray1234 {
			yyl832 := r.ReadArrayStart()
			if yyl832 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl832, 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 yys833Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys833Slc
	var yyhl833 bool = l >= 0
	for yyj833 := 0; ; yyj833++ {
		if yyhl833 {
			if yyj833 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys833Slc = r.DecodeBytes(yys833Slc, true, true)
		yys833 := string(yys833Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys833 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv834 := &x.ObjectMeta
				yyv834.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv835 := &x.Spec
				yyv835.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv836 := &x.Status
				yyv836.CodecDecodeSelf(d)
			}
		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, yys833)
		} // end switch yys833
	} // end for yyj833
	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 yyj839 int
	var yyb839 bool
	var yyhl839 bool = l >= 0
	yyj839++
	if yyhl839 {
		yyb839 = yyj839 > l
	} else {
		yyb839 = r.CheckBreak()
	}
	if yyb839 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv840 := &x.ObjectMeta
		yyv840.CodecDecodeSelf(d)
	}
	yyj839++
	if yyhl839 {
		yyb839 = yyj839 > l
	} else {
		yyb839 = r.CheckBreak()
	}
	if yyb839 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv841 := &x.Spec
		yyv841.CodecDecodeSelf(d)
	}
	yyj839++
	if yyhl839 {
		yyb839 = yyj839 > l
	} else {
		yyb839 = r.CheckBreak()
	}
	if yyb839 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv842 := &x.Status
		yyv842.CodecDecodeSelf(d)
	}
	yyj839++
	if yyhl839 {
		yyb839 = yyj839 > l
	} else {
		yyb839 = r.CheckBreak()
	}
	if yyb839 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj839++
	if yyhl839 {
		yyb839 = yyj839 > l
	} else {
		yyb839 = r.CheckBreak()
	}
	if yyb839 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj839++
		if yyhl839 {
			yyb839 = yyj839 > l
		} else {
			yyb839 = r.CheckBreak()
		}
		if yyb839 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj839-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 {
		yym845 := z.EncBinary()
		_ = yym845
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep846 := !z.EncBinary()
			yy2arr846 := z.EncBasicHandle().StructToArray
			var yyq846 [4]bool
			_, _, _ = yysep846, yyq846, yy2arr846
			const yyr846 bool = false
			yyq846[0] = true
			yyq846[2] = x.Kind != ""
			yyq846[3] = x.APIVersion != ""
			var yynn846 int
			if yyr846 || yy2arr846 {
				r.EncodeArrayStart(4)
			} else {
				yynn846 = 1
				for _, b := range yyq846 {
					if b {
						yynn846++
					}
				}
				r.EncodeMapStart(yynn846)
				yynn846 = 0
			}
			if yyr846 || yy2arr846 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq846[0] {
					yy848 := &x.ListMeta
					yym849 := z.EncBinary()
					_ = yym849
					if false {
					} else if z.HasExtensions() && z.EncExt(yy848) {
					} else {
						z.EncFallback(yy848)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq846[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy850 := &x.ListMeta
					yym851 := z.EncBinary()
					_ = yym851
					if false {
					} else if z.HasExtensions() && z.EncExt(yy850) {
					} else {
						z.EncFallback(yy850)
					}
				}
			}
			if yyr846 || yy2arr846 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym853 := z.EncBinary()
					_ = yym853
					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 {
					yym854 := z.EncBinary()
					_ = yym854
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yyr846 || yy2arr846 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq846[2] {
					yym856 := z.EncBinary()
					_ = yym856
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq846[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym857 := z.EncBinary()
					_ = yym857
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr846 || yy2arr846 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq846[3] {
					yym859 := z.EncBinary()
					_ = yym859
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq846[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym860 := z.EncBinary()
					_ = yym860
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr846 || yy2arr846 {
				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
	yym861 := z.DecBinary()
	_ = yym861
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct862 := r.ContainerType()
		if yyct862 == codecSelferValueTypeMap1234 {
			yyl862 := r.ReadMapStart()
			if yyl862 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl862, d)
			}
		} else if yyct862 == codecSelferValueTypeArray1234 {
			yyl862 := r.ReadArrayStart()
			if yyl862 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl862, 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 yys863Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys863Slc
	var yyhl863 bool = l >= 0
	for yyj863 := 0; ; yyj863++ {
		if yyhl863 {
			if yyj863 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys863Slc = r.DecodeBytes(yys863Slc, true, true)
		yys863 := string(yys863Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys863 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv864 := &x.ListMeta
				yym865 := z.DecBinary()
				_ = yym865
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv864) {
				} else {
					z.DecFallback(yyv864, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv866 := &x.Items
				yym867 := z.DecBinary()
				_ = yym867
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv866), d)
				}
			}
		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, yys863)
		} // end switch yys863
	} // end for yyj863
	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 yyj870 int
	var yyb870 bool
	var yyhl870 bool = l >= 0
	yyj870++
	if yyhl870 {
		yyb870 = yyj870 > l
	} else {
		yyb870 = r.CheckBreak()
	}
	if yyb870 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv871 := &x.ListMeta
		yym872 := z.DecBinary()
		_ = yym872
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv871) {
		} else {
			z.DecFallback(yyv871, false)
		}
	}
	yyj870++
	if yyhl870 {
		yyb870 = yyj870 > l
	} else {
		yyb870 = r.CheckBreak()
	}
	if yyb870 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv873 := &x.Items
		yym874 := z.DecBinary()
		_ = yym874
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv873), d)
		}
	}
	yyj870++
	if yyhl870 {
		yyb870 = yyj870 > l
	} else {
		yyb870 = r.CheckBreak()
	}
	if yyb870 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj870++
	if yyhl870 {
		yyb870 = yyj870 > l
	} else {
		yyb870 = r.CheckBreak()
	}
	if yyb870 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj870++
		if yyhl870 {
			yyb870 = yyj870 > l
		} else {
			yyb870 = r.CheckBreak()
		}
		if yyb870 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj870-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 {
		yym877 := z.EncBinary()
		_ = yym877
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep878 := !z.EncBinary()
			yy2arr878 := z.EncBasicHandle().StructToArray
			var yyq878 [5]bool
			_, _, _ = yysep878, yyq878, yy2arr878
			const yyr878 bool = false
			yyq878[0] = x.Parallelism != nil
			yyq878[1] = x.Completions != nil
			yyq878[2] = x.ActiveDeadlineSeconds != nil
			yyq878[3] = x.Selector != nil
			var yynn878 int
			if yyr878 || yy2arr878 {
				r.EncodeArrayStart(5)
			} else {
				yynn878 = 1
				for _, b := range yyq878 {
					if b {
						yynn878++
					}
				}
				r.EncodeMapStart(yynn878)
				yynn878 = 0
			}
			if yyr878 || yy2arr878 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq878[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy880 := *x.Parallelism
						yym881 := z.EncBinary()
						_ = yym881
						if false {
						} else {
							r.EncodeInt(int64(yy880))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq878[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy882 := *x.Parallelism
						yym883 := z.EncBinary()
						_ = yym883
						if false {
						} else {
							r.EncodeInt(int64(yy882))
						}
					}
				}
			}
			if yyr878 || yy2arr878 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq878[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy885 := *x.Completions
						yym886 := z.EncBinary()
						_ = yym886
						if false {
						} else {
							r.EncodeInt(int64(yy885))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq878[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy887 := *x.Completions
						yym888 := z.EncBinary()
						_ = yym888
						if false {
						} else {
							r.EncodeInt(int64(yy887))
						}
					}
				}
			}
			if yyr878 || yy2arr878 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq878[2] {
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy890 := *x.ActiveDeadlineSeconds
						yym891 := z.EncBinary()
						_ = yym891
						if false {
						} else {
							r.EncodeInt(int64(yy890))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq878[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy892 := *x.ActiveDeadlineSeconds
						yym893 := z.EncBinary()
						_ = yym893
						if false {
						} else {
							r.EncodeInt(int64(yy892))
						}
					}
				}
			}
			if yyr878 || yy2arr878 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq878[3] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq878[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 yyr878 || yy2arr878 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy896 := &x.Template
				yy896.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy897 := &x.Template
				yy897.CodecEncodeSelf(e)
			}
			if yyr878 || yy2arr878 {
				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
	yym898 := z.DecBinary()
	_ = yym898
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct899 := r.ContainerType()
		if yyct899 == codecSelferValueTypeMap1234 {
			yyl899 := r.ReadMapStart()
			if yyl899 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl899, d)
			}
		} else if yyct899 == codecSelferValueTypeArray1234 {
			yyl899 := r.ReadArrayStart()
			if yyl899 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl899, 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 yys900Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys900Slc
	var yyhl900 bool = l >= 0
	for yyj900 := 0; ; yyj900++ {
		if yyhl900 {
			if yyj900 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys900Slc = r.DecodeBytes(yys900Slc, true, true)
		yys900 := string(yys900Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys900 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int32)
				}
				yym902 := z.DecBinary()
				_ = yym902
				if false {
				} else {
					*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
				}
			}
		case "completions":
			if r.TryDecodeAsNil() {
				if x.Completions != nil {
					x.Completions = nil
				}
			} else {
				if x.Completions == nil {
					x.Completions = new(int32)
				}
				yym904 := z.DecBinary()
				_ = yym904
				if false {
				} else {
					*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
				}
			}
		case "activeDeadlineSeconds":
			if r.TryDecodeAsNil() {
				if x.ActiveDeadlineSeconds != nil {
					x.ActiveDeadlineSeconds = nil
				}
			} else {
				if x.ActiveDeadlineSeconds == nil {
					x.ActiveDeadlineSeconds = new(int64)
				}
				yym906 := z.DecBinary()
				_ = yym906
				if false {
				} else {
					*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv908 := &x.Template
				yyv908.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys900)
		} // end switch yys900
	} // end for yyj900
	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 yyj909 int
	var yyb909 bool
	var yyhl909 bool = l >= 0
	yyj909++
	if yyhl909 {
		yyb909 = yyj909 > l
	} else {
		yyb909 = r.CheckBreak()
	}
	if yyb909 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int32)
		}
		yym911 := z.DecBinary()
		_ = yym911
		if false {
		} else {
			*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
		}
	}
	yyj909++
	if yyhl909 {
		yyb909 = yyj909 > l
	} else {
		yyb909 = r.CheckBreak()
	}
	if yyb909 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int32)
		}
		yym913 := z.DecBinary()
		_ = yym913
		if false {
		} else {
			*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
		}
	}
	yyj909++
	if yyhl909 {
		yyb909 = yyj909 > l
	} else {
		yyb909 = r.CheckBreak()
	}
	if yyb909 {
		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)
		}
		yym915 := z.DecBinary()
		_ = yym915
		if false {
		} else {
			*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj909++
	if yyhl909 {
		yyb909 = yyj909 > l
	} else {
		yyb909 = r.CheckBreak()
	}
	if yyb909 {
		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)
	}
	yyj909++
	if yyhl909 {
		yyb909 = yyj909 > l
	} else {
		yyb909 = r.CheckBreak()
	}
	if yyb909 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv917 := &x.Template
		yyv917.CodecDecodeSelf(d)
	}
	for {
		yyj909++
		if yyhl909 {
			yyb909 = yyj909 > l
		} else {
			yyb909 = r.CheckBreak()
		}
		if yyb909 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj909-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 {
		yym918 := z.EncBinary()
		_ = yym918
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep919 := !z.EncBinary()
			yy2arr919 := z.EncBasicHandle().StructToArray
			var yyq919 [6]bool
			_, _, _ = yysep919, yyq919, yy2arr919
			const yyr919 bool = false
			yyq919[0] = len(x.Conditions) != 0
			yyq919[1] = x.StartTime != nil
			yyq919[2] = x.CompletionTime != nil
			yyq919[3] = x.Active != 0
			yyq919[4] = x.Succeeded != 0
			yyq919[5] = x.Failed != 0
			var yynn919 int
			if yyr919 || yy2arr919 {
				r.EncodeArrayStart(6)
			} else {
				yynn919 = 0
				for _, b := range yyq919 {
					if b {
						yynn919++
					}
				}
				r.EncodeMapStart(yynn919)
				yynn919 = 0
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym921 := z.EncBinary()
						_ = yym921
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq919[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym922 := z.EncBinary()
						_ = yym922
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym924 := z.EncBinary()
						_ = yym924
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym924 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym924 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq919[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym925 := z.EncBinary()
						_ = yym925
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym925 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym925 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym927 := z.EncBinary()
						_ = yym927
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym927 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym927 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq919[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym928 := z.EncBinary()
						_ = yym928
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym928 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym928 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[3] {
					yym930 := z.EncBinary()
					_ = yym930
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq919[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym931 := z.EncBinary()
					_ = yym931
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[4] {
					yym933 := z.EncBinary()
					_ = yym933
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq919[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym934 := z.EncBinary()
					_ = yym934
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr919 || yy2arr919 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq919[5] {
					yym936 := z.EncBinary()
					_ = yym936
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq919[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym937 := z.EncBinary()
					_ = yym937
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yyr919 || yy2arr919 {
				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
	yym938 := z.DecBinary()
	_ = yym938
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct939 := r.ContainerType()
		if yyct939 == codecSelferValueTypeMap1234 {
			yyl939 := r.ReadMapStart()
			if yyl939 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl939, d)
			}
		} else if yyct939 == codecSelferValueTypeArray1234 {
			yyl939 := r.ReadArrayStart()
			if yyl939 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl939, 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 yys940Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys940Slc
	var yyhl940 bool = l >= 0
	for yyj940 := 0; ; yyj940++ {
		if yyhl940 {
			if yyj940 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys940Slc = r.DecodeBytes(yys940Slc, true, true)
		yys940 := string(yys940Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys940 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv941 := &x.Conditions
				yym942 := z.DecBinary()
				_ = yym942
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv941), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym944 := z.DecBinary()
				_ = yym944
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym944 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym944 && 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)
				}
				yym946 := z.DecBinary()
				_ = yym946
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym946 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym946 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.CompletionTime)
				} else {
					z.DecFallback(x.CompletionTime, false)
				}
			}
		case "active":
			if r.TryDecodeAsNil() {
				x.Active = 0
			} else {
				x.Active = int32(r.DecodeInt(32))
			}
		case "succeeded":
			if r.TryDecodeAsNil() {
				x.Succeeded = 0
			} else {
				x.Succeeded = int32(r.DecodeInt(32))
			}
		case "failed":
			if r.TryDecodeAsNil() {
				x.Failed = 0
			} else {
				x.Failed = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys940)
		} // end switch yys940
	} // end for yyj940
	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 yyj950 int
	var yyb950 bool
	var yyhl950 bool = l >= 0
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv951 := &x.Conditions
		yym952 := z.DecBinary()
		_ = yym952
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv951), d)
		}
	}
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		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)
		}
		yym954 := z.DecBinary()
		_ = yym954
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym954 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym954 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		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)
		}
		yym956 := z.DecBinary()
		_ = yym956
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym956 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym956 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int32(r.DecodeInt(32))
	}
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int32(r.DecodeInt(32))
	}
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int32(r.DecodeInt(32))
	}
	for {
		yyj950++
		if yyhl950 {
			yyb950 = yyj950 > l
		} else {
			yyb950 = r.CheckBreak()
		}
		if yyb950 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj950-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym960 := z.EncBinary()
	_ = yym960
	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
	yym961 := z.DecBinary()
	_ = yym961
	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 {
		yym962 := z.EncBinary()
		_ = yym962
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep963 := !z.EncBinary()
			yy2arr963 := z.EncBasicHandle().StructToArray
			var yyq963 [6]bool
			_, _, _ = yysep963, yyq963, yy2arr963
			const yyr963 bool = false
			yyq963[2] = true
			yyq963[3] = true
			yyq963[4] = x.Reason != ""
			yyq963[5] = x.Message != ""
			var yynn963 int
			if yyr963 || yy2arr963 {
				r.EncodeArrayStart(6)
			} else {
				yynn963 = 2
				for _, b := range yyq963 {
					if b {
						yynn963++
					}
				}
				r.EncodeMapStart(yynn963)
				yynn963 = 0
			}
			if yyr963 || yy2arr963 {
				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 yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym966 := z.EncBinary()
				_ = yym966
				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)
				yym967 := z.EncBinary()
				_ = yym967
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq963[2] {
					yy969 := &x.LastProbeTime
					yym970 := z.EncBinary()
					_ = yym970
					if false {
					} else if z.HasExtensions() && z.EncExt(yy969) {
					} else if yym970 {
						z.EncBinaryMarshal(yy969)
					} else if !yym970 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy969)
					} else {
						z.EncFallback(yy969)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq963[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy971 := &x.LastProbeTime
					yym972 := z.EncBinary()
					_ = yym972
					if false {
					} else if z.HasExtensions() && z.EncExt(yy971) {
					} else if yym972 {
						z.EncBinaryMarshal(yy971)
					} else if !yym972 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy971)
					} else {
						z.EncFallback(yy971)
					}
				}
			}
			if yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq963[3] {
					yy974 := &x.LastTransitionTime
					yym975 := z.EncBinary()
					_ = yym975
					if false {
					} else if z.HasExtensions() && z.EncExt(yy974) {
					} else if yym975 {
						z.EncBinaryMarshal(yy974)
					} else if !yym975 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy974)
					} else {
						z.EncFallback(yy974)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq963[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy976 := &x.LastTransitionTime
					yym977 := z.EncBinary()
					_ = yym977
					if false {
					} else if z.HasExtensions() && z.EncExt(yy976) {
					} else if yym977 {
						z.EncBinaryMarshal(yy976)
					} else if !yym977 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy976)
					} else {
						z.EncFallback(yy976)
					}
				}
			}
			if yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq963[4] {
					yym979 := z.EncBinary()
					_ = yym979
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq963[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym980 := z.EncBinary()
					_ = yym980
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr963 || yy2arr963 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq963[5] {
					yym982 := z.EncBinary()
					_ = yym982
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq963[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym983 := z.EncBinary()
					_ = yym983
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr963 || yy2arr963 {
				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
	yym984 := z.DecBinary()
	_ = yym984
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct985 := r.ContainerType()
		if yyct985 == codecSelferValueTypeMap1234 {
			yyl985 := r.ReadMapStart()
			if yyl985 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl985, d)
			}
		} else if yyct985 == codecSelferValueTypeArray1234 {
			yyl985 := r.ReadArrayStart()
			if yyl985 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl985, 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 yys986Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys986Slc
	var yyhl986 bool = l >= 0
	for yyj986 := 0; ; yyj986++ {
		if yyhl986 {
			if yyj986 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys986Slc = r.DecodeBytes(yys986Slc, true, true)
		yys986 := string(yys986Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys986 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = JobConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
			}
		case "lastProbeTime":
			if r.TryDecodeAsNil() {
				x.LastProbeTime = pkg1_unversioned.Time{}
			} else {
				yyv989 := &x.LastProbeTime
				yym990 := z.DecBinary()
				_ = yym990
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv989) {
				} else if yym990 {
					z.DecBinaryUnmarshal(yyv989)
				} else if !yym990 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv989)
				} else {
					z.DecFallback(yyv989, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv991 := &x.LastTransitionTime
				yym992 := z.DecBinary()
				_ = yym992
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv991) {
				} else if yym992 {
					z.DecBinaryUnmarshal(yyv991)
				} else if !yym992 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv991)
				} else {
					z.DecFallback(yyv991, 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, yys986)
		} // end switch yys986
	} // end for yyj986
	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 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.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	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.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	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.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv998 := &x.LastProbeTime
		yym999 := z.DecBinary()
		_ = yym999
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv998) {
		} else if yym999 {
			z.DecBinaryUnmarshal(yyv998)
		} else if !yym999 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv998)
		} else {
			z.DecFallback(yyv998, false)
		}
	}
	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.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv1000 := &x.LastTransitionTime
		yym1001 := z.DecBinary()
		_ = yym1001
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1000) {
		} else if yym1001 {
			z.DecBinaryUnmarshal(yyv1000)
		} else if !yym1001 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1000)
		} else {
			z.DecFallback(yyv1000, false)
		}
	}
	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.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	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.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	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 *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1004 := z.EncBinary()
		_ = yym1004
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1005 := !z.EncBinary()
			yy2arr1005 := z.EncBasicHandle().StructToArray
			var yyq1005 [5]bool
			_, _, _ = yysep1005, yyq1005, yy2arr1005
			const yyr1005 bool = false
			yyq1005[0] = true
			yyq1005[1] = true
			yyq1005[2] = true
			yyq1005[3] = x.Kind != ""
			yyq1005[4] = x.APIVersion != ""
			var yynn1005 int
			if yyr1005 || yy2arr1005 {
				r.EncodeArrayStart(5)
			} else {
				yynn1005 = 0
				for _, b := range yyq1005 {
					if b {
						yynn1005++
					}
				}
				r.EncodeMapStart(yynn1005)
				yynn1005 = 0
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[0] {
					yy1007 := &x.ObjectMeta
					yy1007.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1005[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1008 := &x.ObjectMeta
					yy1008.CodecEncodeSelf(e)
				}
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[1] {
					yy1010 := &x.Spec
					yy1010.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1005[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1011 := &x.Spec
					yy1011.CodecEncodeSelf(e)
				}
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[2] {
					yy1013 := &x.Status
					yy1013.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1005[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1014 := &x.Status
					yy1014.CodecEncodeSelf(e)
				}
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[3] {
					yym1016 := z.EncBinary()
					_ = yym1016
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1005[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1017 := z.EncBinary()
					_ = yym1017
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1005 || yy2arr1005 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1005[4] {
					yym1019 := z.EncBinary()
					_ = yym1019
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1005[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1020 := z.EncBinary()
					_ = yym1020
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1005 || yy2arr1005 {
				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
	yym1021 := z.DecBinary()
	_ = yym1021
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1022 := r.ContainerType()
		if yyct1022 == codecSelferValueTypeMap1234 {
			yyl1022 := r.ReadMapStart()
			if yyl1022 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1022, d)
			}
		} else if yyct1022 == codecSelferValueTypeArray1234 {
			yyl1022 := r.ReadArrayStart()
			if yyl1022 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1022, 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 yys1023Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1023Slc
	var yyhl1023 bool = l >= 0
	for yyj1023 := 0; ; yyj1023++ {
		if yyhl1023 {
			if yyj1023 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1023Slc = r.DecodeBytes(yys1023Slc, true, true)
		yys1023 := string(yys1023Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1023 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1024 := &x.ObjectMeta
				yyv1024.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv1025 := &x.Spec
				yyv1025.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv1026 := &x.Status
				yyv1026.CodecDecodeSelf(d)
			}
		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, yys1023)
		} // end switch yys1023
	} // end for yyj1023
	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 yyj1029 int
	var yyb1029 bool
	var yyhl1029 bool = l >= 0
	yyj1029++
	if yyhl1029 {
		yyb1029 = yyj1029 > l
	} else {
		yyb1029 = r.CheckBreak()
	}
	if yyb1029 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1030 := &x.ObjectMeta
		yyv1030.CodecDecodeSelf(d)
	}
	yyj1029++
	if yyhl1029 {
		yyb1029 = yyj1029 > l
	} else {
		yyb1029 = r.CheckBreak()
	}
	if yyb1029 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv1031 := &x.Spec
		yyv1031.CodecDecodeSelf(d)
	}
	yyj1029++
	if yyhl1029 {
		yyb1029 = yyj1029 > l
	} else {
		yyb1029 = r.CheckBreak()
	}
	if yyb1029 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv1032 := &x.Status
		yyv1032.CodecDecodeSelf(d)
	}
	yyj1029++
	if yyhl1029 {
		yyb1029 = yyj1029 > l
	} else {
		yyb1029 = r.CheckBreak()
	}
	if yyb1029 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1029++
	if yyhl1029 {
		yyb1029 = yyj1029 > l
	} else {
		yyb1029 = r.CheckBreak()
	}
	if yyb1029 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1029++
		if yyhl1029 {
			yyb1029 = yyj1029 > l
		} else {
			yyb1029 = r.CheckBreak()
		}
		if yyb1029 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1029-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 {
		yym1035 := z.EncBinary()
		_ = yym1035
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1036 := !z.EncBinary()
			yy2arr1036 := z.EncBasicHandle().StructToArray
			var yyq1036 [4]bool
			_, _, _ = yysep1036, yyq1036, yy2arr1036
			const yyr1036 bool = false
			yyq1036[0] = true
			yyq1036[2] = x.Kind != ""
			yyq1036[3] = x.APIVersion != ""
			var yynn1036 int
			if yyr1036 || yy2arr1036 {
				r.EncodeArrayStart(4)
			} else {
				yynn1036 = 1
				for _, b := range yyq1036 {
					if b {
						yynn1036++
					}
				}
				r.EncodeMapStart(yynn1036)
				yynn1036 = 0
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[0] {
					yy1038 := &x.ListMeta
					yym1039 := z.EncBinary()
					_ = yym1039
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1038) {
					} else {
						z.EncFallback(yy1038)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1036[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1040 := &x.ListMeta
					yym1041 := z.EncBinary()
					_ = yym1041
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1040) {
					} else {
						z.EncFallback(yy1040)
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1043 := z.EncBinary()
					_ = yym1043
					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 {
					yym1044 := z.EncBinary()
					_ = yym1044
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[2] {
					yym1046 := z.EncBinary()
					_ = yym1046
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1036[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1047 := z.EncBinary()
					_ = yym1047
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[3] {
					yym1049 := z.EncBinary()
					_ = yym1049
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1036[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1050 := z.EncBinary()
					_ = yym1050
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				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
	yym1051 := z.DecBinary()
	_ = yym1051
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1052 := r.ContainerType()
		if yyct1052 == codecSelferValueTypeMap1234 {
			yyl1052 := r.ReadMapStart()
			if yyl1052 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1052, d)
			}
		} else if yyct1052 == codecSelferValueTypeArray1234 {
			yyl1052 := r.ReadArrayStart()
			if yyl1052 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1052, 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 yys1053Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1053Slc
	var yyhl1053 bool = l >= 0
	for yyj1053 := 0; ; yyj1053++ {
		if yyhl1053 {
			if yyj1053 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1053Slc = r.DecodeBytes(yys1053Slc, true, true)
		yys1053 := string(yys1053Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1053 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1054 := &x.ListMeta
				yym1055 := z.DecBinary()
				_ = yym1055
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1054) {
				} else {
					z.DecFallback(yyv1054, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1056 := &x.Items
				yym1057 := z.DecBinary()
				_ = yym1057
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv1056), d)
				}
			}
		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, yys1053)
		} // end switch yys1053
	} // end for yyj1053
	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 yyj1060 int
	var yyb1060 bool
	var yyhl1060 bool = l >= 0
	yyj1060++
	if yyhl1060 {
		yyb1060 = yyj1060 > l
	} else {
		yyb1060 = r.CheckBreak()
	}
	if yyb1060 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1061 := &x.ListMeta
		yym1062 := z.DecBinary()
		_ = yym1062
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1061) {
		} else {
			z.DecFallback(yyv1061, false)
		}
	}
	yyj1060++
	if yyhl1060 {
		yyb1060 = yyj1060 > l
	} else {
		yyb1060 = r.CheckBreak()
	}
	if yyb1060 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1063 := &x.Items
		yym1064 := z.DecBinary()
		_ = yym1064
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv1063), d)
		}
	}
	yyj1060++
	if yyhl1060 {
		yyb1060 = yyj1060 > l
	} else {
		yyb1060 = r.CheckBreak()
	}
	if yyb1060 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1060++
	if yyhl1060 {
		yyb1060 = yyj1060 > l
	} else {
		yyb1060 = r.CheckBreak()
	}
	if yyb1060 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1060++
		if yyhl1060 {
			yyb1060 = yyj1060 > l
		} else {
			yyb1060 = r.CheckBreak()
		}
		if yyb1060 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1060-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 {
		yym1067 := z.EncBinary()
		_ = yym1067
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1068 := !z.EncBinary()
			yy2arr1068 := z.EncBasicHandle().StructToArray
			var yyq1068 [3]bool
			_, _, _ = yysep1068, yyq1068, yy2arr1068
			const yyr1068 bool = false
			yyq1068[0] = x.Backend != nil
			yyq1068[1] = len(x.TLS) != 0
			yyq1068[2] = len(x.Rules) != 0
			var yynn1068 int
			if yyr1068 || yy2arr1068 {
				r.EncodeArrayStart(3)
			} else {
				yynn1068 = 0
				for _, b := range yyq1068 {
					if b {
						yynn1068++
					}
				}
				r.EncodeMapStart(yynn1068)
				yynn1068 = 0
			}
			if yyr1068 || yy2arr1068 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1068[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1068[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 yyr1068 || yy2arr1068 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1068[1] {
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1071 := z.EncBinary()
						_ = yym1071
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1068[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("tls"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1072 := z.EncBinary()
						_ = yym1072
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				}
			}
			if yyr1068 || yy2arr1068 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1068[2] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1074 := z.EncBinary()
						_ = yym1074
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1068[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1075 := z.EncBinary()
						_ = yym1075
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr1068 || yy2arr1068 {
				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
	yym1076 := z.DecBinary()
	_ = yym1076
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1077 := r.ContainerType()
		if yyct1077 == codecSelferValueTypeMap1234 {
			yyl1077 := r.ReadMapStart()
			if yyl1077 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1077, d)
			}
		} else if yyct1077 == codecSelferValueTypeArray1234 {
			yyl1077 := r.ReadArrayStart()
			if yyl1077 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1077, 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 yys1078Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1078Slc
	var yyhl1078 bool = l >= 0
	for yyj1078 := 0; ; yyj1078++ {
		if yyhl1078 {
			if yyj1078 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1078Slc = r.DecodeBytes(yys1078Slc, true, true)
		yys1078 := string(yys1078Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1078 {
		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 "tls":
			if r.TryDecodeAsNil() {
				x.TLS = nil
			} else {
				yyv1080 := &x.TLS
				yym1081 := z.DecBinary()
				_ = yym1081
				if false {
				} else {
					h.decSliceIngressTLS((*[]IngressTLS)(yyv1080), d)
				}
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv1082 := &x.Rules
				yym1083 := z.DecBinary()
				_ = yym1083
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv1082), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1078)
		} // end switch yys1078
	} // end for yyj1078
	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 yyj1084 int
	var yyb1084 bool
	var yyhl1084 bool = l >= 0
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		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)
	}
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TLS = nil
	} else {
		yyv1086 := &x.TLS
		yym1087 := z.DecBinary()
		_ = yym1087
		if false {
		} else {
			h.decSliceIngressTLS((*[]IngressTLS)(yyv1086), d)
		}
	}
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv1088 := &x.Rules
		yym1089 := z.DecBinary()
		_ = yym1089
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv1088), d)
		}
	}
	for {
		yyj1084++
		if yyhl1084 {
			yyb1084 = yyj1084 > l
		} else {
			yyb1084 = r.CheckBreak()
		}
		if yyb1084 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1084-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1090 := z.EncBinary()
		_ = yym1090
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1091 := !z.EncBinary()
			yy2arr1091 := z.EncBasicHandle().StructToArray
			var yyq1091 [2]bool
			_, _, _ = yysep1091, yyq1091, yy2arr1091
			const yyr1091 bool = false
			yyq1091[0] = len(x.Hosts) != 0
			yyq1091[1] = x.SecretName != ""
			var yynn1091 int
			if yyr1091 || yy2arr1091 {
				r.EncodeArrayStart(2)
			} else {
				yynn1091 = 0
				for _, b := range yyq1091 {
					if b {
						yynn1091++
					}
				}
				r.EncodeMapStart(yynn1091)
				yynn1091 = 0
			}
			if yyr1091 || yy2arr1091 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1091[0] {
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1093 := z.EncBinary()
						_ = yym1093
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1091[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hosts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1094 := z.EncBinary()
						_ = yym1094
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				}
			}
			if yyr1091 || yy2arr1091 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1091[1] {
					yym1096 := z.EncBinary()
					_ = yym1096
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1091[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("secretName"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1097 := z.EncBinary()
					_ = yym1097
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				}
			}
			if yyr1091 || yy2arr1091 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1100Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1100Slc
	var yyhl1100 bool = l >= 0
	for yyj1100 := 0; ; yyj1100++ {
		if yyhl1100 {
			if yyj1100 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1100Slc = r.DecodeBytes(yys1100Slc, true, true)
		yys1100 := string(yys1100Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1100 {
		case "hosts":
			if r.TryDecodeAsNil() {
				x.Hosts = nil
			} else {
				yyv1101 := &x.Hosts
				yym1102 := z.DecBinary()
				_ = yym1102
				if false {
				} else {
					z.F.DecSliceStringX(yyv1101, false, d)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1100)
		} // end switch yys1100
	} // end for yyj1100
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressTLS) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1104 int
	var yyb1104 bool
	var yyhl1104 bool = l >= 0
	yyj1104++
	if yyhl1104 {
		yyb1104 = yyj1104 > l
	} else {
		yyb1104 = r.CheckBreak()
	}
	if yyb1104 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Hosts = nil
	} else {
		yyv1105 := &x.Hosts
		yym1106 := z.DecBinary()
		_ = yym1106
		if false {
		} else {
			z.F.DecSliceStringX(yyv1105, false, d)
		}
	}
	yyj1104++
	if yyhl1104 {
		yyb1104 = yyj1104 > l
	} else {
		yyb1104 = r.CheckBreak()
	}
	if yyb1104 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	for {
		yyj1104++
		if yyhl1104 {
			yyb1104 = yyj1104 > l
		} else {
			yyb1104 = r.CheckBreak()
		}
		if yyb1104 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1104-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 {
		yym1108 := z.EncBinary()
		_ = yym1108
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1109 := !z.EncBinary()
			yy2arr1109 := z.EncBasicHandle().StructToArray
			var yyq1109 [1]bool
			_, _, _ = yysep1109, yyq1109, yy2arr1109
			const yyr1109 bool = false
			yyq1109[0] = true
			var yynn1109 int
			if yyr1109 || yy2arr1109 {
				r.EncodeArrayStart(1)
			} else {
				yynn1109 = 0
				for _, b := range yyq1109 {
					if b {
						yynn1109++
					}
				}
				r.EncodeMapStart(yynn1109)
				yynn1109 = 0
			}
			if yyr1109 || yy2arr1109 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1109[0] {
					yy1111 := &x.LoadBalancer
					yy1111.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1109[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1112 := &x.LoadBalancer
					yy1112.CodecEncodeSelf(e)
				}
			}
			if yyr1109 || yy2arr1109 {
				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
	yym1113 := z.DecBinary()
	_ = yym1113
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1114 := r.ContainerType()
		if yyct1114 == codecSelferValueTypeMap1234 {
			yyl1114 := r.ReadMapStart()
			if yyl1114 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1114, d)
			}
		} else if yyct1114 == codecSelferValueTypeArray1234 {
			yyl1114 := r.ReadArrayStart()
			if yyl1114 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1114, 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 yys1115Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1115Slc
	var yyhl1115 bool = l >= 0
	for yyj1115 := 0; ; yyj1115++ {
		if yyhl1115 {
			if yyj1115 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1115Slc = r.DecodeBytes(yys1115Slc, true, true)
		yys1115 := string(yys1115Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1115 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
			} else {
				yyv1116 := &x.LoadBalancer
				yyv1116.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1115)
		} // end switch yys1115
	} // end for yyj1115
	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 yyj1117 int
	var yyb1117 bool
	var yyhl1117 bool = l >= 0
	yyj1117++
	if yyhl1117 {
		yyb1117 = yyj1117 > l
	} else {
		yyb1117 = r.CheckBreak()
	}
	if yyb1117 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv1118 := &x.LoadBalancer
		yyv1118.CodecDecodeSelf(d)
	}
	for {
		yyj1117++
		if yyhl1117 {
			yyb1117 = yyj1117 > l
		} else {
			yyb1117 = r.CheckBreak()
		}
		if yyb1117 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1117-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 {
		yym1119 := z.EncBinary()
		_ = yym1119
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1120 := !z.EncBinary()
			yy2arr1120 := z.EncBasicHandle().StructToArray
			var yyq1120 [2]bool
			_, _, _ = yysep1120, yyq1120, yy2arr1120
			const yyr1120 bool = false
			yyq1120[0] = x.Host != ""
			yyq1120[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn1120 int
			if yyr1120 || yy2arr1120 {
				r.EncodeArrayStart(2)
			} else {
				yynn1120 = 0
				for _, b := range yyq1120 {
					if b {
						yynn1120++
					}
				}
				r.EncodeMapStart(yynn1120)
				yynn1120 = 0
			}
			if yyr1120 || yy2arr1120 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1120[0] {
					yym1122 := z.EncBinary()
					_ = yym1122
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1120[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1123 := z.EncBinary()
					_ = yym1123
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn1124 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn1124 = true
				goto LABEL1124
			}
		LABEL1124:
			if yyr1120 || yy2arr1120 {
				if yyn1124 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq1120[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq1120[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn1124 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr1120 || yy2arr1120 {
				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
	yym1125 := z.DecBinary()
	_ = yym1125
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1126 := r.ContainerType()
		if yyct1126 == codecSelferValueTypeMap1234 {
			yyl1126 := r.ReadMapStart()
			if yyl1126 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1126, d)
			}
		} else if yyct1126 == codecSelferValueTypeArray1234 {
			yyl1126 := r.ReadArrayStart()
			if yyl1126 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1126, 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 yys1127Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1127Slc
	var yyhl1127 bool = l >= 0
	for yyj1127 := 0; ; yyj1127++ {
		if yyhl1127 {
			if yyj1127 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1127Slc = r.DecodeBytes(yys1127Slc, true, true)
		yys1127 := string(yys1127Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1127 {
		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, yys1127)
		} // end switch yys1127
	} // end for yyj1127
	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 yyj1130 int
	var yyb1130 bool
	var yyhl1130 bool = l >= 0
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Host = ""
	} else {
		x.Host = string(r.DecodeString())
	}
	if x.IngressRuleValue.HTTP == nil {
		x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
	}
	yyj1130++
	if yyhl1130 {
		yyb1130 = yyj1130 > l
	} else {
		yyb1130 = r.CheckBreak()
	}
	if yyb1130 {
		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 {
		yyj1130++
		if yyhl1130 {
			yyb1130 = yyj1130 > l
		} else {
			yyb1130 = r.CheckBreak()
		}
		if yyb1130 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1130-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1133 := z.EncBinary()
		_ = yym1133
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1134 := !z.EncBinary()
			yy2arr1134 := z.EncBasicHandle().StructToArray
			var yyq1134 [1]bool
			_, _, _ = yysep1134, yyq1134, yy2arr1134
			const yyr1134 bool = false
			yyq1134[0] = x.HTTP != nil
			var yynn1134 int
			if yyr1134 || yy2arr1134 {
				r.EncodeArrayStart(1)
			} else {
				yynn1134 = 0
				for _, b := range yyq1134 {
					if b {
						yynn1134++
					}
				}
				r.EncodeMapStart(yynn1134)
				yynn1134 = 0
			}
			if yyr1134 || yy2arr1134 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1134[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1134[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 yyr1134 || yy2arr1134 {
				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
	yym1136 := z.DecBinary()
	_ = yym1136
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1137 := r.ContainerType()
		if yyct1137 == codecSelferValueTypeMap1234 {
			yyl1137 := r.ReadMapStart()
			if yyl1137 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1137, d)
			}
		} else if yyct1137 == codecSelferValueTypeArray1234 {
			yyl1137 := r.ReadArrayStart()
			if yyl1137 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1137, 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 yys1138Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1138Slc
	var yyhl1138 bool = l >= 0
	for yyj1138 := 0; ; yyj1138++ {
		if yyhl1138 {
			if yyj1138 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1138Slc = r.DecodeBytes(yys1138Slc, true, true)
		yys1138 := string(yys1138Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1138 {
		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, yys1138)
		} // end switch yys1138
	} // end for yyj1138
	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 yyj1140 int
	var yyb1140 bool
	var yyhl1140 bool = l >= 0
	yyj1140++
	if yyhl1140 {
		yyb1140 = yyj1140 > l
	} else {
		yyb1140 = r.CheckBreak()
	}
	if yyb1140 {
		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 {
		yyj1140++
		if yyhl1140 {
			yyb1140 = yyj1140 > l
		} else {
			yyb1140 = r.CheckBreak()
		}
		if yyb1140 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1140-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 {
		yym1142 := z.EncBinary()
		_ = yym1142
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1143 := !z.EncBinary()
			yy2arr1143 := z.EncBasicHandle().StructToArray
			var yyq1143 [1]bool
			_, _, _ = yysep1143, yyq1143, yy2arr1143
			const yyr1143 bool = false
			var yynn1143 int
			if yyr1143 || yy2arr1143 {
				r.EncodeArrayStart(1)
			} else {
				yynn1143 = 1
				for _, b := range yyq1143 {
					if b {
						yynn1143++
					}
				}
				r.EncodeMapStart(yynn1143)
				yynn1143 = 0
			}
			if yyr1143 || yy2arr1143 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym1145 := z.EncBinary()
					_ = yym1145
					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 {
					yym1146 := z.EncBinary()
					_ = yym1146
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr1143 || yy2arr1143 {
				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
	yym1147 := z.DecBinary()
	_ = yym1147
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1148 := r.ContainerType()
		if yyct1148 == codecSelferValueTypeMap1234 {
			yyl1148 := r.ReadMapStart()
			if yyl1148 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1148, d)
			}
		} else if yyct1148 == codecSelferValueTypeArray1234 {
			yyl1148 := r.ReadArrayStart()
			if yyl1148 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1148, 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 yys1149Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1149Slc
	var yyhl1149 bool = l >= 0
	for yyj1149 := 0; ; yyj1149++ {
		if yyhl1149 {
			if yyj1149 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1149Slc = r.DecodeBytes(yys1149Slc, true, true)
		yys1149 := string(yys1149Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1149 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv1150 := &x.Paths
				yym1151 := z.DecBinary()
				_ = yym1151
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1150), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1149)
		} // end switch yys1149
	} // end for yyj1149
	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 yyj1152 int
	var yyb1152 bool
	var yyhl1152 bool = l >= 0
	yyj1152++
	if yyhl1152 {
		yyb1152 = yyj1152 > l
	} else {
		yyb1152 = r.CheckBreak()
	}
	if yyb1152 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv1153 := &x.Paths
		yym1154 := z.DecBinary()
		_ = yym1154
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1153), d)
		}
	}
	for {
		yyj1152++
		if yyhl1152 {
			yyb1152 = yyj1152 > l
		} else {
			yyb1152 = r.CheckBreak()
		}
		if yyb1152 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1152-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 {
		yym1155 := z.EncBinary()
		_ = yym1155
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1156 := !z.EncBinary()
			yy2arr1156 := z.EncBasicHandle().StructToArray
			var yyq1156 [2]bool
			_, _, _ = yysep1156, yyq1156, yy2arr1156
			const yyr1156 bool = false
			yyq1156[0] = x.Path != ""
			var yynn1156 int
			if yyr1156 || yy2arr1156 {
				r.EncodeArrayStart(2)
			} else {
				yynn1156 = 1
				for _, b := range yyq1156 {
					if b {
						yynn1156++
					}
				}
				r.EncodeMapStart(yynn1156)
				yynn1156 = 0
			}
			if yyr1156 || yy2arr1156 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1156[0] {
					yym1158 := z.EncBinary()
					_ = yym1158
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1156[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1159 := z.EncBinary()
					_ = yym1159
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr1156 || yy2arr1156 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1161 := &x.Backend
				yy1161.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1162 := &x.Backend
				yy1162.CodecEncodeSelf(e)
			}
			if yyr1156 || yy2arr1156 {
				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
	yym1163 := z.DecBinary()
	_ = yym1163
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1164 := r.ContainerType()
		if yyct1164 == codecSelferValueTypeMap1234 {
			yyl1164 := r.ReadMapStart()
			if yyl1164 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1164, d)
			}
		} else if yyct1164 == codecSelferValueTypeArray1234 {
			yyl1164 := r.ReadArrayStart()
			if yyl1164 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1164, 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 yys1165Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1165Slc
	var yyhl1165 bool = l >= 0
	for yyj1165 := 0; ; yyj1165++ {
		if yyhl1165 {
			if yyj1165 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1165Slc = r.DecodeBytes(yys1165Slc, true, true)
		yys1165 := string(yys1165Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1165 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv1167 := &x.Backend
				yyv1167.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1165)
		} // end switch yys1165
	} // end for yyj1165
	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 yyj1168 int
	var yyb1168 bool
	var yyhl1168 bool = l >= 0
	yyj1168++
	if yyhl1168 {
		yyb1168 = yyj1168 > l
	} else {
		yyb1168 = r.CheckBreak()
	}
	if yyb1168 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj1168++
	if yyhl1168 {
		yyb1168 = yyj1168 > l
	} else {
		yyb1168 = r.CheckBreak()
	}
	if yyb1168 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv1170 := &x.Backend
		yyv1170.CodecDecodeSelf(d)
	}
	for {
		yyj1168++
		if yyhl1168 {
			yyb1168 = yyj1168 > l
		} else {
			yyb1168 = r.CheckBreak()
		}
		if yyb1168 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1168-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 {
		yym1171 := z.EncBinary()
		_ = yym1171
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1172 := !z.EncBinary()
			yy2arr1172 := z.EncBasicHandle().StructToArray
			var yyq1172 [2]bool
			_, _, _ = yysep1172, yyq1172, yy2arr1172
			const yyr1172 bool = false
			var yynn1172 int
			if yyr1172 || yy2arr1172 {
				r.EncodeArrayStart(2)
			} else {
				yynn1172 = 2
				for _, b := range yyq1172 {
					if b {
						yynn1172++
					}
				}
				r.EncodeMapStart(yynn1172)
				yynn1172 = 0
			}
			if yyr1172 || yy2arr1172 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1174 := z.EncBinary()
				_ = yym1174
				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)
				yym1175 := z.EncBinary()
				_ = yym1175
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr1172 || yy2arr1172 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1177 := &x.ServicePort
				yym1178 := z.EncBinary()
				_ = yym1178
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1177) {
				} else if !yym1178 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1177)
				} else {
					z.EncFallback(yy1177)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1179 := &x.ServicePort
				yym1180 := z.EncBinary()
				_ = yym1180
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1179) {
				} else if !yym1180 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1179)
				} else {
					z.EncFallback(yy1179)
				}
			}
			if yyr1172 || yy2arr1172 {
				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
	yym1181 := z.DecBinary()
	_ = yym1181
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1182 := r.ContainerType()
		if yyct1182 == codecSelferValueTypeMap1234 {
			yyl1182 := r.ReadMapStart()
			if yyl1182 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1182, d)
			}
		} else if yyct1182 == codecSelferValueTypeArray1234 {
			yyl1182 := r.ReadArrayStart()
			if yyl1182 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1182, 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 yys1183Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1183Slc
	var yyhl1183 bool = l >= 0
	for yyj1183 := 0; ; yyj1183++ {
		if yyhl1183 {
			if yyj1183 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1183Slc = r.DecodeBytes(yys1183Slc, true, true)
		yys1183 := string(yys1183Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1183 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg6_intstr.IntOrString{}
			} else {
				yyv1185 := &x.ServicePort
				yym1186 := z.DecBinary()
				_ = yym1186
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1185) {
				} else if !yym1186 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1185)
				} else {
					z.DecFallback(yyv1185, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1183)
		} // end switch yys1183
	} // end for yyj1183
	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 yyj1187 int
	var yyb1187 bool
	var yyhl1187 bool = l >= 0
	yyj1187++
	if yyhl1187 {
		yyb1187 = yyj1187 > l
	} else {
		yyb1187 = r.CheckBreak()
	}
	if yyb1187 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj1187++
	if yyhl1187 {
		yyb1187 = yyj1187 > l
	} else {
		yyb1187 = r.CheckBreak()
	}
	if yyb1187 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg6_intstr.IntOrString{}
	} else {
		yyv1189 := &x.ServicePort
		yym1190 := z.DecBinary()
		_ = yym1190
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1189) {
		} else if !yym1190 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1189)
		} else {
			z.DecFallback(yyv1189, false)
		}
	}
	for {
		yyj1187++
		if yyhl1187 {
			yyb1187 = yyj1187 > l
		} else {
			yyb1187 = r.CheckBreak()
		}
		if yyb1187 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1187-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1191 := z.EncBinary()
	_ = yym1191
	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
	yym1192 := z.DecBinary()
	_ = yym1192
	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 {
		yym1193 := z.EncBinary()
		_ = yym1193
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1194 := !z.EncBinary()
			yy2arr1194 := z.EncBasicHandle().StructToArray
			var yyq1194 [2]bool
			_, _, _ = yysep1194, yyq1194, yy2arr1194
			const yyr1194 bool = false
			var yynn1194 int
			if yyr1194 || yy2arr1194 {
				r.EncodeArrayStart(2)
			} else {
				yynn1194 = 2
				for _, b := range yyq1194 {
					if b {
						yynn1194++
					}
				}
				r.EncodeMapStart(yynn1194)
				yynn1194 = 0
			}
			if yyr1194 || yy2arr1194 {
				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 yyr1194 || yy2arr1194 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1197 := z.EncBinary()
				_ = yym1197
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1198 := z.EncBinary()
				_ = yym1198
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yyr1194 || yy2arr1194 {
				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
	yym1199 := z.DecBinary()
	_ = yym1199
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1200 := r.ContainerType()
		if yyct1200 == codecSelferValueTypeMap1234 {
			yyl1200 := r.ReadMapStart()
			if yyl1200 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1200, d)
			}
		} else if yyct1200 == codecSelferValueTypeArray1234 {
			yyl1200 := r.ReadArrayStart()
			if yyl1200 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1200, 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 yys1201Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1201Slc
	var yyhl1201 bool = l >= 0
	for yyj1201 := 0; ; yyj1201++ {
		if yyhl1201 {
			if yyj1201 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1201Slc = r.DecodeBytes(yys1201Slc, true, true)
		yys1201 := string(yys1201Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1201 {
		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, yys1201)
		} // end switch yys1201
	} // end for yyj1201
	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 yyj1204 int
	var yyb1204 bool
	var yyhl1204 bool = l >= 0
	yyj1204++
	if yyhl1204 {
		yyb1204 = yyj1204 > l
	} else {
		yyb1204 = r.CheckBreak()
	}
	if yyb1204 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj1204++
	if yyhl1204 {
		yyb1204 = yyj1204 > l
	} else {
		yyb1204 = r.CheckBreak()
	}
	if yyb1204 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj1204++
		if yyhl1204 {
			yyb1204 = yyj1204 > l
		} else {
			yyb1204 = r.CheckBreak()
		}
		if yyb1204 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1204-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 {
		yym1207 := z.EncBinary()
		_ = yym1207
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1208 := !z.EncBinary()
			yy2arr1208 := z.EncBasicHandle().StructToArray
			var yyq1208 [3]bool
			_, _, _ = yysep1208, yyq1208, yy2arr1208
			const yyr1208 bool = false
			var yynn1208 int
			if yyr1208 || yy2arr1208 {
				r.EncodeArrayStart(3)
			} else {
				yynn1208 = 3
				for _, b := range yyq1208 {
					if b {
						yynn1208++
					}
				}
				r.EncodeMapStart(yynn1208)
				yynn1208 = 0
			}
			if yyr1208 || yy2arr1208 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1210 := z.EncBinary()
				_ = yym1210
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1211 := z.EncBinary()
				_ = yym1211
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1208 || yy2arr1208 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1213 := z.EncBinary()
				_ = yym1213
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1214 := z.EncBinary()
				_ = yym1214
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1208 || yy2arr1208 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1216 := z.EncBinary()
					_ = yym1216
					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 {
					yym1217 := z.EncBinary()
					_ = yym1217
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yyr1208 || yy2arr1208 {
				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
	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 *ClusterAutoscalerSpec) 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 "minNodes":
			if r.TryDecodeAsNil() {
				x.MinNodes = 0
			} else {
				x.MinNodes = int32(r.DecodeInt(32))
			}
		case "maxNodes":
			if r.TryDecodeAsNil() {
				x.MaxNodes = 0
			} else {
				x.MaxNodes = int32(r.DecodeInt(32))
			}
		case "target":
			if r.TryDecodeAsNil() {
				x.TargetUtilization = nil
			} else {
				yyv1223 := &x.TargetUtilization
				yym1224 := z.DecBinary()
				_ = yym1224
				if false {
				} else {
					h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1223), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1220)
		} // end switch yys1220
	} // end for yyj1220
	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 yyj1225 int
	var yyb1225 bool
	var yyhl1225 bool = l >= 0
	yyj1225++
	if yyhl1225 {
		yyb1225 = yyj1225 > l
	} else {
		yyb1225 = r.CheckBreak()
	}
	if yyb1225 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int32(r.DecodeInt(32))
	}
	yyj1225++
	if yyhl1225 {
		yyb1225 = yyj1225 > l
	} else {
		yyb1225 = r.CheckBreak()
	}
	if yyb1225 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int32(r.DecodeInt(32))
	}
	yyj1225++
	if yyhl1225 {
		yyb1225 = yyj1225 > l
	} else {
		yyb1225 = r.CheckBreak()
	}
	if yyb1225 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1228 := &x.TargetUtilization
		yym1229 := z.DecBinary()
		_ = yym1229
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1228), d)
		}
	}
	for {
		yyj1225++
		if yyhl1225 {
			yyb1225 = yyj1225 > l
		} else {
			yyb1225 = r.CheckBreak()
		}
		if yyb1225 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1225-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 {
		yym1230 := z.EncBinary()
		_ = yym1230
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1231 := !z.EncBinary()
			yy2arr1231 := z.EncBasicHandle().StructToArray
			var yyq1231 [4]bool
			_, _, _ = yysep1231, yyq1231, yy2arr1231
			const yyr1231 bool = false
			yyq1231[0] = true
			yyq1231[1] = true
			yyq1231[2] = x.Kind != ""
			yyq1231[3] = x.APIVersion != ""
			var yynn1231 int
			if yyr1231 || yy2arr1231 {
				r.EncodeArrayStart(4)
			} else {
				yynn1231 = 0
				for _, b := range yyq1231 {
					if b {
						yynn1231++
					}
				}
				r.EncodeMapStart(yynn1231)
				yynn1231 = 0
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[0] {
					yy1233 := &x.ObjectMeta
					yy1233.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1231[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1234 := &x.ObjectMeta
					yy1234.CodecEncodeSelf(e)
				}
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[1] {
					yy1236 := &x.Spec
					yy1236.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1231[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1237 := &x.Spec
					yy1237.CodecEncodeSelf(e)
				}
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[2] {
					yym1239 := z.EncBinary()
					_ = yym1239
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1231[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1240 := z.EncBinary()
					_ = yym1240
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1231 || yy2arr1231 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1231[3] {
					yym1242 := z.EncBinary()
					_ = yym1242
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1231[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1243 := z.EncBinary()
					_ = yym1243
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1231 || yy2arr1231 {
				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
	yym1244 := z.DecBinary()
	_ = yym1244
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1245 := r.ContainerType()
		if yyct1245 == codecSelferValueTypeMap1234 {
			yyl1245 := r.ReadMapStart()
			if yyl1245 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1245, d)
			}
		} else if yyct1245 == codecSelferValueTypeArray1234 {
			yyl1245 := r.ReadArrayStart()
			if yyl1245 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1245, 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 yys1246Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1246Slc
	var yyhl1246 bool = l >= 0
	for yyj1246 := 0; ; yyj1246++ {
		if yyhl1246 {
			if yyj1246 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1246Slc = r.DecodeBytes(yys1246Slc, true, true)
		yys1246 := string(yys1246Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1246 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1247 := &x.ObjectMeta
				yyv1247.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ClusterAutoscalerSpec{}
			} else {
				yyv1248 := &x.Spec
				yyv1248.CodecDecodeSelf(d)
			}
		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, yys1246)
		} // end switch yys1246
	} // end for yyj1246
	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 yyj1251 int
	var yyb1251 bool
	var yyhl1251 bool = l >= 0
	yyj1251++
	if yyhl1251 {
		yyb1251 = yyj1251 > l
	} else {
		yyb1251 = r.CheckBreak()
	}
	if yyb1251 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1252 := &x.ObjectMeta
		yyv1252.CodecDecodeSelf(d)
	}
	yyj1251++
	if yyhl1251 {
		yyb1251 = yyj1251 > l
	} else {
		yyb1251 = r.CheckBreak()
	}
	if yyb1251 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1253 := &x.Spec
		yyv1253.CodecDecodeSelf(d)
	}
	yyj1251++
	if yyhl1251 {
		yyb1251 = yyj1251 > l
	} else {
		yyb1251 = r.CheckBreak()
	}
	if yyb1251 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1251++
	if yyhl1251 {
		yyb1251 = yyj1251 > l
	} else {
		yyb1251 = r.CheckBreak()
	}
	if yyb1251 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1251++
		if yyhl1251 {
			yyb1251 = yyj1251 > l
		} else {
			yyb1251 = r.CheckBreak()
		}
		if yyb1251 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1251-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 {
		yym1256 := z.EncBinary()
		_ = yym1256
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1257 := !z.EncBinary()
			yy2arr1257 := z.EncBasicHandle().StructToArray
			var yyq1257 [4]bool
			_, _, _ = yysep1257, yyq1257, yy2arr1257
			const yyr1257 bool = false
			yyq1257[0] = true
			yyq1257[2] = x.Kind != ""
			yyq1257[3] = x.APIVersion != ""
			var yynn1257 int
			if yyr1257 || yy2arr1257 {
				r.EncodeArrayStart(4)
			} else {
				yynn1257 = 1
				for _, b := range yyq1257 {
					if b {
						yynn1257++
					}
				}
				r.EncodeMapStart(yynn1257)
				yynn1257 = 0
			}
			if yyr1257 || yy2arr1257 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1257[0] {
					yy1259 := &x.ListMeta
					yym1260 := z.EncBinary()
					_ = yym1260
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1259) {
					} else {
						z.EncFallback(yy1259)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1257[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1261 := &x.ListMeta
					yym1262 := z.EncBinary()
					_ = yym1262
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1261) {
					} else {
						z.EncFallback(yy1261)
					}
				}
			}
			if yyr1257 || yy2arr1257 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1264 := z.EncBinary()
					_ = yym1264
					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 {
					yym1265 := z.EncBinary()
					_ = yym1265
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr1257 || yy2arr1257 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1257[2] {
					yym1267 := z.EncBinary()
					_ = yym1267
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1257[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1268 := z.EncBinary()
					_ = yym1268
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1257 || yy2arr1257 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1257[3] {
					yym1270 := z.EncBinary()
					_ = yym1270
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1257[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1271 := z.EncBinary()
					_ = yym1271
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1257 || yy2arr1257 {
				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
	yym1272 := z.DecBinary()
	_ = yym1272
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1273 := r.ContainerType()
		if yyct1273 == codecSelferValueTypeMap1234 {
			yyl1273 := r.ReadMapStart()
			if yyl1273 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1273, d)
			}
		} else if yyct1273 == codecSelferValueTypeArray1234 {
			yyl1273 := r.ReadArrayStart()
			if yyl1273 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1273, 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 yys1274Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1274Slc
	var yyhl1274 bool = l >= 0
	for yyj1274 := 0; ; yyj1274++ {
		if yyhl1274 {
			if yyj1274 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1274Slc = r.DecodeBytes(yys1274Slc, true, true)
		yys1274 := string(yys1274Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1274 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1275 := &x.ListMeta
				yym1276 := z.DecBinary()
				_ = yym1276
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1275) {
				} else {
					z.DecFallback(yyv1275, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1277 := &x.Items
				yym1278 := z.DecBinary()
				_ = yym1278
				if false {
				} else {
					h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1277), d)
				}
			}
		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, yys1274)
		} // end switch yys1274
	} // end for yyj1274
	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 yyj1281 int
	var yyb1281 bool
	var yyhl1281 bool = l >= 0
	yyj1281++
	if yyhl1281 {
		yyb1281 = yyj1281 > l
	} else {
		yyb1281 = r.CheckBreak()
	}
	if yyb1281 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1282 := &x.ListMeta
		yym1283 := z.DecBinary()
		_ = yym1283
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1282) {
		} else {
			z.DecFallback(yyv1282, false)
		}
	}
	yyj1281++
	if yyhl1281 {
		yyb1281 = yyj1281 > l
	} else {
		yyb1281 = r.CheckBreak()
	}
	if yyb1281 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1284 := &x.Items
		yym1285 := z.DecBinary()
		_ = yym1285
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1284), d)
		}
	}
	yyj1281++
	if yyhl1281 {
		yyb1281 = yyj1281 > l
	} else {
		yyb1281 = r.CheckBreak()
	}
	if yyb1281 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1281++
	if yyhl1281 {
		yyb1281 = yyj1281 > l
	} else {
		yyb1281 = r.CheckBreak()
	}
	if yyb1281 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1281++
		if yyhl1281 {
			yyb1281 = yyj1281 > l
		} else {
			yyb1281 = r.CheckBreak()
		}
		if yyb1281 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1281-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1288 := z.EncBinary()
		_ = yym1288
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1289 := !z.EncBinary()
			yy2arr1289 := z.EncBasicHandle().StructToArray
			var yyq1289 [4]bool
			_, _, _ = yysep1289, yyq1289, yy2arr1289
			const yyr1289 bool = false
			yyq1289[2] = x.Kind != ""
			yyq1289[3] = x.APIVersion != ""
			var yynn1289 int
			if yyr1289 || yy2arr1289 {
				r.EncodeArrayStart(4)
			} else {
				yynn1289 = 2
				for _, b := range yyq1289 {
					if b {
						yynn1289++
					}
				}
				r.EncodeMapStart(yynn1289)
				yynn1289 = 0
			}
			if yyr1289 || yy2arr1289 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1291 := z.EncBinary()
				_ = yym1291
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("export"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1292 := z.EncBinary()
				_ = yym1292
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			}
			if yyr1289 || yy2arr1289 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1294 := z.EncBinary()
				_ = yym1294
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("exact"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1295 := z.EncBinary()
				_ = yym1295
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			}
			if yyr1289 || yy2arr1289 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1289[2] {
					yym1297 := z.EncBinary()
					_ = yym1297
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1289[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1298 := z.EncBinary()
					_ = yym1298
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1289 || yy2arr1289 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1289[3] {
					yym1300 := z.EncBinary()
					_ = yym1300
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1289[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1301 := z.EncBinary()
					_ = yym1301
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1289 || yy2arr1289 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1304Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1304Slc
	var yyhl1304 bool = l >= 0
	for yyj1304 := 0; ; yyj1304++ {
		if yyhl1304 {
			if yyj1304 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1304Slc = r.DecodeBytes(yys1304Slc, true, true)
		yys1304 := string(yys1304Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1304 {
		case "export":
			if r.TryDecodeAsNil() {
				x.Export = false
			} else {
				x.Export = bool(r.DecodeBool())
			}
		case "exact":
			if r.TryDecodeAsNil() {
				x.Exact = false
			} else {
				x.Exact = bool(r.DecodeBool())
			}
		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, yys1304)
		} // end switch yys1304
	} // end for yyj1304
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

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

func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1314 := z.EncBinary()
		_ = yym1314
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1315 := !z.EncBinary()
			yy2arr1315 := z.EncBasicHandle().StructToArray
			var yyq1315 [7]bool
			_, _, _ = yysep1315, yyq1315, yy2arr1315
			const yyr1315 bool = false
			yyq1315[0] = x.LabelSelector != ""
			yyq1315[1] = x.FieldSelector != ""
			yyq1315[2] = x.Watch != false
			yyq1315[3] = x.ResourceVersion != ""
			yyq1315[4] = x.TimeoutSeconds != nil
			yyq1315[5] = x.Kind != ""
			yyq1315[6] = x.APIVersion != ""
			var yynn1315 int
			if yyr1315 || yy2arr1315 {
				r.EncodeArrayStart(7)
			} else {
				yynn1315 = 0
				for _, b := range yyq1315 {
					if b {
						yynn1315++
					}
				}
				r.EncodeMapStart(yynn1315)
				yynn1315 = 0
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[0] {
					yym1317 := z.EncBinary()
					_ = yym1317
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1315[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1318 := z.EncBinary()
					_ = yym1318
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[1] {
					yym1320 := z.EncBinary()
					_ = yym1320
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1315[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fieldSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1321 := z.EncBinary()
					_ = yym1321
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[2] {
					yym1323 := z.EncBinary()
					_ = yym1323
					if false {
					} else {
						r.EncodeBool(bool(x.Watch))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1315[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("watch"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1324 := z.EncBinary()
					_ = yym1324
					if false {
					} else {
						r.EncodeBool(bool(x.Watch))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[3] {
					yym1326 := z.EncBinary()
					_ = yym1326
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1315[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("resourceVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1327 := z.EncBinary()
					_ = yym1327
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[4] {
					if x.TimeoutSeconds == nil {
						r.EncodeNil()
					} else {
						yy1329 := *x.TimeoutSeconds
						yym1330 := z.EncBinary()
						_ = yym1330
						if false {
						} else {
							r.EncodeInt(int64(yy1329))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1315[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("timeoutSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TimeoutSeconds == nil {
						r.EncodeNil()
					} else {
						yy1331 := *x.TimeoutSeconds
						yym1332 := z.EncBinary()
						_ = yym1332
						if false {
						} else {
							r.EncodeInt(int64(yy1331))
						}
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[5] {
					yym1334 := z.EncBinary()
					_ = yym1334
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1315[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1335 := z.EncBinary()
					_ = yym1335
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1315[6] {
					yym1337 := z.EncBinary()
					_ = yym1337
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1315[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1338 := z.EncBinary()
					_ = yym1338
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1315 || yy2arr1315 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1341Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1341Slc
	var yyhl1341 bool = l >= 0
	for yyj1341 := 0; ; yyj1341++ {
		if yyhl1341 {
			if yyj1341 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1341Slc = r.DecodeBytes(yys1341Slc, true, true)
		yys1341 := string(yys1341Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1341 {
		case "labelSelector":
			if r.TryDecodeAsNil() {
				x.LabelSelector = ""
			} else {
				x.LabelSelector = string(r.DecodeString())
			}
		case "fieldSelector":
			if r.TryDecodeAsNil() {
				x.FieldSelector = ""
			} else {
				x.FieldSelector = string(r.DecodeString())
			}
		case "watch":
			if r.TryDecodeAsNil() {
				x.Watch = false
			} else {
				x.Watch = bool(r.DecodeBool())
			}
		case "resourceVersion":
			if r.TryDecodeAsNil() {
				x.ResourceVersion = ""
			} else {
				x.ResourceVersion = string(r.DecodeString())
			}
		case "timeoutSeconds":
			if r.TryDecodeAsNil() {
				if x.TimeoutSeconds != nil {
					x.TimeoutSeconds = nil
				}
			} else {
				if x.TimeoutSeconds == nil {
					x.TimeoutSeconds = new(int64)
				}
				yym1347 := z.DecBinary()
				_ = yym1347
				if false {
				} else {
					*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
				}
			}
		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, yys1341)
		} // end switch yys1341
	} // end for yyj1341
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1350 int
	var yyb1350 bool
	var yyhl1350 bool = l >= 0
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LabelSelector = ""
	} else {
		x.LabelSelector = string(r.DecodeString())
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FieldSelector = ""
	} else {
		x.FieldSelector = string(r.DecodeString())
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Watch = false
	} else {
		x.Watch = bool(r.DecodeBool())
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ResourceVersion = ""
	} else {
		x.ResourceVersion = string(r.DecodeString())
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.TimeoutSeconds != nil {
			x.TimeoutSeconds = nil
		}
	} else {
		if x.TimeoutSeconds == nil {
			x.TimeoutSeconds = new(int64)
		}
		yym1356 := z.DecBinary()
		_ = yym1356
		if false {
		} else {
			*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1350++
	if yyhl1350 {
		yyb1350 = yyj1350 > l
	} else {
		yyb1350 = r.CheckBreak()
	}
	if yyb1350 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1350++
		if yyhl1350 {
			yyb1350 = yyj1350 > l
		} else {
			yyb1350 = r.CheckBreak()
		}
		if yyb1350 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1350-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 {
		yym1359 := z.EncBinary()
		_ = yym1359
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1360 := !z.EncBinary()
			yy2arr1360 := z.EncBasicHandle().StructToArray
			var yyq1360 [2]bool
			_, _, _ = yysep1360, yyq1360, yy2arr1360
			const yyr1360 bool = false
			yyq1360[0] = len(x.MatchLabels) != 0
			yyq1360[1] = len(x.MatchExpressions) != 0
			var yynn1360 int
			if yyr1360 || yy2arr1360 {
				r.EncodeArrayStart(2)
			} else {
				yynn1360 = 0
				for _, b := range yyq1360 {
					if b {
						yynn1360++
					}
				}
				r.EncodeMapStart(yynn1360)
				yynn1360 = 0
			}
			if yyr1360 || yy2arr1360 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1360[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1362 := z.EncBinary()
						_ = yym1362
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1360[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1363 := z.EncBinary()
						_ = yym1363
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1360 || yy2arr1360 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1360[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1365 := z.EncBinary()
						_ = yym1365
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1360[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1366 := z.EncBinary()
						_ = yym1366
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yyr1360 || yy2arr1360 {
				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
	yym1367 := z.DecBinary()
	_ = yym1367
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1368 := r.ContainerType()
		if yyct1368 == codecSelferValueTypeMap1234 {
			yyl1368 := r.ReadMapStart()
			if yyl1368 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1368, d)
			}
		} else if yyct1368 == codecSelferValueTypeArray1234 {
			yyl1368 := r.ReadArrayStart()
			if yyl1368 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1368, 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 yys1369Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1369Slc
	var yyhl1369 bool = l >= 0
	for yyj1369 := 0; ; yyj1369++ {
		if yyhl1369 {
			if yyj1369 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1369Slc = r.DecodeBytes(yys1369Slc, true, true)
		yys1369 := string(yys1369Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1369 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1370 := &x.MatchLabels
				yym1371 := z.DecBinary()
				_ = yym1371
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1370, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1372 := &x.MatchExpressions
				yym1373 := z.DecBinary()
				_ = yym1373
				if false {
				} else {
					h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1372), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1369)
		} // end switch yys1369
	} // end for yyj1369
	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 yyj1374 int
	var yyb1374 bool
	var yyhl1374 bool = l >= 0
	yyj1374++
	if yyhl1374 {
		yyb1374 = yyj1374 > l
	} else {
		yyb1374 = r.CheckBreak()
	}
	if yyb1374 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1375 := &x.MatchLabels
		yym1376 := z.DecBinary()
		_ = yym1376
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1375, false, d)
		}
	}
	yyj1374++
	if yyhl1374 {
		yyb1374 = yyj1374 > l
	} else {
		yyb1374 = r.CheckBreak()
	}
	if yyb1374 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1377 := &x.MatchExpressions
		yym1378 := z.DecBinary()
		_ = yym1378
		if false {
		} else {
			h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1377), d)
		}
	}
	for {
		yyj1374++
		if yyhl1374 {
			yyb1374 = yyj1374 > l
		} else {
			yyb1374 = r.CheckBreak()
		}
		if yyb1374 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1374-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 {
		yym1379 := z.EncBinary()
		_ = yym1379
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1380 := !z.EncBinary()
			yy2arr1380 := z.EncBasicHandle().StructToArray
			var yyq1380 [3]bool
			_, _, _ = yysep1380, yyq1380, yy2arr1380
			const yyr1380 bool = false
			yyq1380[2] = len(x.Values) != 0
			var yynn1380 int
			if yyr1380 || yy2arr1380 {
				r.EncodeArrayStart(3)
			} else {
				yynn1380 = 2
				for _, b := range yyq1380 {
					if b {
						yynn1380++
					}
				}
				r.EncodeMapStart(yynn1380)
				yynn1380 = 0
			}
			if yyr1380 || yy2arr1380 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1382 := z.EncBinary()
				_ = yym1382
				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)
				yym1383 := z.EncBinary()
				_ = yym1383
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1380 || yy2arr1380 {
				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 yyr1380 || yy2arr1380 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1380[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1386 := z.EncBinary()
						_ = yym1386
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1380[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1387 := z.EncBinary()
						_ = yym1387
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yyr1380 || yy2arr1380 {
				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
	yym1388 := z.DecBinary()
	_ = yym1388
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1389 := r.ContainerType()
		if yyct1389 == codecSelferValueTypeMap1234 {
			yyl1389 := r.ReadMapStart()
			if yyl1389 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1389, d)
			}
		} else if yyct1389 == codecSelferValueTypeArray1234 {
			yyl1389 := r.ReadArrayStart()
			if yyl1389 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1389, 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 yys1390Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1390Slc
	var yyhl1390 bool = l >= 0
	for yyj1390 := 0; ; yyj1390++ {
		if yyhl1390 {
			if yyj1390 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1390Slc = r.DecodeBytes(yys1390Slc, true, true)
		yys1390 := string(yys1390Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1390 {
		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 {
				yyv1393 := &x.Values
				yym1394 := z.DecBinary()
				_ = yym1394
				if false {
				} else {
					z.F.DecSliceStringX(yyv1393, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1390)
		} // end switch yys1390
	} // end for yyj1390
	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 yyj1395 int
	var yyb1395 bool
	var yyhl1395 bool = l >= 0
	yyj1395++
	if yyhl1395 {
		yyb1395 = yyj1395 > l
	} else {
		yyb1395 = r.CheckBreak()
	}
	if yyb1395 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1395++
	if yyhl1395 {
		yyb1395 = yyj1395 > l
	} else {
		yyb1395 = r.CheckBreak()
	}
	if yyb1395 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = LabelSelectorOperator(r.DecodeString())
	}
	yyj1395++
	if yyhl1395 {
		yyb1395 = yyj1395 > l
	} else {
		yyb1395 = r.CheckBreak()
	}
	if yyb1395 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1398 := &x.Values
		yym1399 := z.DecBinary()
		_ = yym1399
		if false {
		} else {
			z.F.DecSliceStringX(yyv1398, false, d)
		}
	}
	for {
		yyj1395++
		if yyhl1395 {
			yyb1395 = yyj1395 > l
		} else {
			yyb1395 = r.CheckBreak()
		}
		if yyb1395 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1395-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1400 := z.EncBinary()
	_ = yym1400
	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
	yym1401 := z.DecBinary()
	_ = yym1401
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1402 := z.EncBinary()
		_ = yym1402
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1403 := !z.EncBinary()
			yy2arr1403 := z.EncBasicHandle().StructToArray
			var yyq1403 [5]bool
			_, _, _ = yysep1403, yyq1403, yy2arr1403
			const yyr1403 bool = false
			yyq1403[0] = true
			yyq1403[1] = true
			yyq1403[2] = true
			yyq1403[3] = x.Kind != ""
			yyq1403[4] = x.APIVersion != ""
			var yynn1403 int
			if yyr1403 || yy2arr1403 {
				r.EncodeArrayStart(5)
			} else {
				yynn1403 = 0
				for _, b := range yyq1403 {
					if b {
						yynn1403++
					}
				}
				r.EncodeMapStart(yynn1403)
				yynn1403 = 0
			}
			if yyr1403 || yy2arr1403 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1403[0] {
					yy1405 := &x.ObjectMeta
					yy1405.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1403[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1406 := &x.ObjectMeta
					yy1406.CodecEncodeSelf(e)
				}
			}
			if yyr1403 || yy2arr1403 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1403[1] {
					yy1408 := &x.Spec
					yy1408.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1403[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1409 := &x.Spec
					yy1409.CodecEncodeSelf(e)
				}
			}
			if yyr1403 || yy2arr1403 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1403[2] {
					yy1411 := &x.Status
					yy1411.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1403[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1412 := &x.Status
					yy1412.CodecEncodeSelf(e)
				}
			}
			if yyr1403 || yy2arr1403 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1403[3] {
					yym1414 := z.EncBinary()
					_ = yym1414
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1403[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1415 := z.EncBinary()
					_ = yym1415
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1403 || yy2arr1403 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1403[4] {
					yym1417 := z.EncBinary()
					_ = yym1417
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1403[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1418 := z.EncBinary()
					_ = yym1418
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1403 || yy2arr1403 {
				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
	yym1419 := z.DecBinary()
	_ = yym1419
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1420 := r.ContainerType()
		if yyct1420 == codecSelferValueTypeMap1234 {
			yyl1420 := r.ReadMapStart()
			if yyl1420 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1420, d)
			}
		} else if yyct1420 == codecSelferValueTypeArray1234 {
			yyl1420 := r.ReadArrayStart()
			if yyl1420 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1420, 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 yys1421Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1421Slc
	var yyhl1421 bool = l >= 0
	for yyj1421 := 0; ; yyj1421++ {
		if yyhl1421 {
			if yyj1421 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1421Slc = r.DecodeBytes(yys1421Slc, true, true)
		yys1421 := string(yys1421Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1421 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1422 := &x.ObjectMeta
				yyv1422.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv1423 := &x.Spec
				yyv1423.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv1424 := &x.Status
				yyv1424.CodecDecodeSelf(d)
			}
		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, yys1421)
		} // end switch yys1421
	} // end for yyj1421
	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 yyj1427 int
	var yyb1427 bool
	var yyhl1427 bool = l >= 0
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1428 := &x.ObjectMeta
		yyv1428.CodecDecodeSelf(d)
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv1429 := &x.Spec
		yyv1429.CodecDecodeSelf(d)
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv1430 := &x.Status
		yyv1430.CodecDecodeSelf(d)
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1427++
		if yyhl1427 {
			yyb1427 = yyj1427 > l
		} else {
			yyb1427 = r.CheckBreak()
		}
		if yyb1427 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1427-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 {
		yym1433 := z.EncBinary()
		_ = yym1433
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1434 := !z.EncBinary()
			yy2arr1434 := z.EncBasicHandle().StructToArray
			var yyq1434 [4]bool
			_, _, _ = yysep1434, yyq1434, yy2arr1434
			const yyr1434 bool = false
			yyq1434[0] = true
			yyq1434[2] = x.Kind != ""
			yyq1434[3] = x.APIVersion != ""
			var yynn1434 int
			if yyr1434 || yy2arr1434 {
				r.EncodeArrayStart(4)
			} else {
				yynn1434 = 1
				for _, b := range yyq1434 {
					if b {
						yynn1434++
					}
				}
				r.EncodeMapStart(yynn1434)
				yynn1434 = 0
			}
			if yyr1434 || yy2arr1434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1434[0] {
					yy1436 := &x.ListMeta
					yym1437 := z.EncBinary()
					_ = yym1437
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1436) {
					} else {
						z.EncFallback(yy1436)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1434[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1438 := &x.ListMeta
					yym1439 := z.EncBinary()
					_ = yym1439
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1438) {
					} else {
						z.EncFallback(yy1438)
					}
				}
			}
			if yyr1434 || yy2arr1434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1441 := z.EncBinary()
					_ = yym1441
					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 {
					yym1442 := z.EncBinary()
					_ = yym1442
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr1434 || yy2arr1434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1434[2] {
					yym1444 := z.EncBinary()
					_ = yym1444
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1434[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1445 := z.EncBinary()
					_ = yym1445
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1434 || yy2arr1434 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1434[3] {
					yym1447 := z.EncBinary()
					_ = yym1447
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1434[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1448 := z.EncBinary()
					_ = yym1448
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1434 || yy2arr1434 {
				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
	yym1449 := z.DecBinary()
	_ = yym1449
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1450 := r.ContainerType()
		if yyct1450 == codecSelferValueTypeMap1234 {
			yyl1450 := r.ReadMapStart()
			if yyl1450 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1450, d)
			}
		} else if yyct1450 == codecSelferValueTypeArray1234 {
			yyl1450 := r.ReadArrayStart()
			if yyl1450 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1450, 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 yys1451Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1451Slc
	var yyhl1451 bool = l >= 0
	for yyj1451 := 0; ; yyj1451++ {
		if yyhl1451 {
			if yyj1451 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1451Slc = r.DecodeBytes(yys1451Slc, true, true)
		yys1451 := string(yys1451Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1451 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1452 := &x.ListMeta
				yym1453 := z.DecBinary()
				_ = yym1453
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1452) {
				} else {
					z.DecFallback(yyv1452, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1454 := &x.Items
				yym1455 := z.DecBinary()
				_ = yym1455
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv1454), d)
				}
			}
		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, yys1451)
		} // end switch yys1451
	} // end for yyj1451
	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 yyj1458 int
	var yyb1458 bool
	var yyhl1458 bool = l >= 0
	yyj1458++
	if yyhl1458 {
		yyb1458 = yyj1458 > l
	} else {
		yyb1458 = r.CheckBreak()
	}
	if yyb1458 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1459 := &x.ListMeta
		yym1460 := z.DecBinary()
		_ = yym1460
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1459) {
		} else {
			z.DecFallback(yyv1459, false)
		}
	}
	yyj1458++
	if yyhl1458 {
		yyb1458 = yyj1458 > l
	} else {
		yyb1458 = r.CheckBreak()
	}
	if yyb1458 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1461 := &x.Items
		yym1462 := z.DecBinary()
		_ = yym1462
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv1461), d)
		}
	}
	yyj1458++
	if yyhl1458 {
		yyb1458 = yyj1458 > l
	} else {
		yyb1458 = r.CheckBreak()
	}
	if yyb1458 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1458++
	if yyhl1458 {
		yyb1458 = yyj1458 > l
	} else {
		yyb1458 = r.CheckBreak()
	}
	if yyb1458 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1458++
		if yyhl1458 {
			yyb1458 = yyj1458 > l
		} else {
			yyb1458 = r.CheckBreak()
		}
		if yyb1458 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1458-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 {
		yym1465 := z.EncBinary()
		_ = yym1465
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1466 := !z.EncBinary()
			yy2arr1466 := z.EncBasicHandle().StructToArray
			var yyq1466 [3]bool
			_, _, _ = yysep1466, yyq1466, yy2arr1466
			const yyr1466 bool = false
			yyq1466[0] = x.Replicas != nil
			yyq1466[1] = x.Selector != nil
			yyq1466[2] = x.Template != nil
			var yynn1466 int
			if yyr1466 || yy2arr1466 {
				r.EncodeArrayStart(3)
			} else {
				yynn1466 = 0
				for _, b := range yyq1466 {
					if b {
						yynn1466++
					}
				}
				r.EncodeMapStart(yynn1466)
				yynn1466 = 0
			}
			if yyr1466 || yy2arr1466 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1466[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1468 := *x.Replicas
						yym1469 := z.EncBinary()
						_ = yym1469
						if false {
						} else {
							r.EncodeInt(int64(yy1468))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1466[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1470 := *x.Replicas
						yym1471 := z.EncBinary()
						_ = yym1471
						if false {
						} else {
							r.EncodeInt(int64(yy1470))
						}
					}
				}
			}
			if yyr1466 || yy2arr1466 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1466[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1466[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 yyr1466 || yy2arr1466 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1466[2] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1466[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 yyr1466 || yy2arr1466 {
				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
	yym1474 := z.DecBinary()
	_ = yym1474
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1475 := r.ContainerType()
		if yyct1475 == codecSelferValueTypeMap1234 {
			yyl1475 := r.ReadMapStart()
			if yyl1475 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1475, d)
			}
		} else if yyct1475 == codecSelferValueTypeArray1234 {
			yyl1475 := r.ReadArrayStart()
			if yyl1475 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1475, 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 yys1476Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1476Slc
	var yyhl1476 bool = l >= 0
	for yyj1476 := 0; ; yyj1476++ {
		if yyhl1476 {
			if yyj1476 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1476Slc = r.DecodeBytes(yys1476Slc, true, true)
		yys1476 := string(yys1476Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1476 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym1478 := z.DecBinary()
				_ = yym1478
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				if x.Template != nil {
					x.Template = nil
				}
			} else {
				if x.Template == nil {
					x.Template = new(pkg2_v1.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1476)
		} // end switch yys1476
	} // end for yyj1476
	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 yyj1481 int
	var yyb1481 bool
	var yyhl1481 bool = l >= 0
	yyj1481++
	if yyhl1481 {
		yyb1481 = yyj1481 > l
	} else {
		yyb1481 = r.CheckBreak()
	}
	if yyb1481 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym1483 := z.DecBinary()
		_ = yym1483
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj1481++
	if yyhl1481 {
		yyb1481 = yyj1481 > l
	} else {
		yyb1481 = r.CheckBreak()
	}
	if yyb1481 {
		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)
	}
	yyj1481++
	if yyhl1481 {
		yyb1481 = yyj1481 > l
	} else {
		yyb1481 = r.CheckBreak()
	}
	if yyb1481 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_v1.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj1481++
		if yyhl1481 {
			yyb1481 = yyj1481 > l
		} else {
			yyb1481 = r.CheckBreak()
		}
		if yyb1481 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1481-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 {
		yym1486 := z.EncBinary()
		_ = yym1486
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1487 := !z.EncBinary()
			yy2arr1487 := z.EncBasicHandle().StructToArray
			var yyq1487 [2]bool
			_, _, _ = yysep1487, yyq1487, yy2arr1487
			const yyr1487 bool = false
			yyq1487[1] = x.ObservedGeneration != 0
			var yynn1487 int
			if yyr1487 || yy2arr1487 {
				r.EncodeArrayStart(2)
			} else {
				yynn1487 = 1
				for _, b := range yyq1487 {
					if b {
						yynn1487++
					}
				}
				r.EncodeMapStart(yynn1487)
				yynn1487 = 0
			}
			if yyr1487 || yy2arr1487 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1489 := z.EncBinary()
				_ = yym1489
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1490 := z.EncBinary()
				_ = yym1490
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1487 || yy2arr1487 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1487[1] {
					yym1492 := z.EncBinary()
					_ = yym1492
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1487[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1493 := z.EncBinary()
					_ = yym1493
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr1487 || yy2arr1487 {
				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
	yym1494 := z.DecBinary()
	_ = yym1494
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1495 := r.ContainerType()
		if yyct1495 == codecSelferValueTypeMap1234 {
			yyl1495 := r.ReadMapStart()
			if yyl1495 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1495, d)
			}
		} else if yyct1495 == codecSelferValueTypeArray1234 {
			yyl1495 := r.ReadArrayStart()
			if yyl1495 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1495, 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 yys1496Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1496Slc
	var yyhl1496 bool = l >= 0
	for yyj1496 := 0; ; yyj1496++ {
		if yyhl1496 {
			if yyj1496 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1496Slc = r.DecodeBytes(yys1496Slc, true, true)
		yys1496 := string(yys1496Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1496 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1496)
		} // end switch yys1496
	} // end for yyj1496
	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 yyj1499 int
	var yyb1499 bool
	var yyhl1499 bool = l >= 0
	yyj1499++
	if yyhl1499 {
		yyb1499 = yyj1499 > l
	} else {
		yyb1499 = r.CheckBreak()
	}
	if yyb1499 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj1499++
	if yyhl1499 {
		yyb1499 = yyj1499 > l
	} else {
		yyb1499 = r.CheckBreak()
	}
	if yyb1499 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	for {
		yyj1499++
		if yyhl1499 {
			yyb1499 = yyj1499 > l
		} else {
			yyb1499 = r.CheckBreak()
		}
		if yyb1499 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1499-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1502 := z.EncBinary()
		_ = yym1502
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1503 := !z.EncBinary()
			yy2arr1503 := z.EncBasicHandle().StructToArray
			var yyq1503 [4]bool
			_, _, _ = yysep1503, yyq1503, yy2arr1503
			const yyr1503 bool = false
			yyq1503[0] = true
			yyq1503[1] = true
			yyq1503[2] = x.Kind != ""
			yyq1503[3] = x.APIVersion != ""
			var yynn1503 int
			if yyr1503 || yy2arr1503 {
				r.EncodeArrayStart(4)
			} else {
				yynn1503 = 0
				for _, b := range yyq1503 {
					if b {
						yynn1503++
					}
				}
				r.EncodeMapStart(yynn1503)
				yynn1503 = 0
			}
			if yyr1503 || yy2arr1503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1503[0] {
					yy1505 := &x.ObjectMeta
					yy1505.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1503[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1506 := &x.ObjectMeta
					yy1506.CodecEncodeSelf(e)
				}
			}
			if yyr1503 || yy2arr1503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1503[1] {
					yy1508 := &x.Spec
					yy1508.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1503[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1509 := &x.Spec
					yy1509.CodecEncodeSelf(e)
				}
			}
			if yyr1503 || yy2arr1503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1503[2] {
					yym1511 := z.EncBinary()
					_ = yym1511
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1503[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1512 := z.EncBinary()
					_ = yym1512
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1503 || yy2arr1503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1503[3] {
					yym1514 := z.EncBinary()
					_ = yym1514
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1503[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1515 := z.EncBinary()
					_ = yym1515
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1503 || yy2arr1503 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1518Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1518Slc
	var yyhl1518 bool = l >= 0
	for yyj1518 := 0; ; yyj1518++ {
		if yyhl1518 {
			if yyj1518 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1518Slc = r.DecodeBytes(yys1518Slc, true, true)
		yys1518 := string(yys1518Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1518 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1519 := &x.ObjectMeta
				yyv1519.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = PodSecurityPolicySpec{}
			} else {
				yyv1520 := &x.Spec
				yyv1520.CodecDecodeSelf(d)
			}
		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, yys1518)
		} // end switch yys1518
	} // end for yyj1518
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1523 int
	var yyb1523 bool
	var yyhl1523 bool = l >= 0
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1524 := &x.ObjectMeta
		yyv1524.CodecDecodeSelf(d)
	}
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = PodSecurityPolicySpec{}
	} else {
		yyv1525 := &x.Spec
		yyv1525.CodecDecodeSelf(d)
	}
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1523++
		if yyhl1523 {
			yyb1523 = yyj1523 > l
		} else {
			yyb1523 = r.CheckBreak()
		}
		if yyb1523 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1523-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1528 := z.EncBinary()
		_ = yym1528
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1529 := !z.EncBinary()
			yy2arr1529 := z.EncBasicHandle().StructToArray
			var yyq1529 [9]bool
			_, _, _ = yysep1529, yyq1529, yy2arr1529
			const yyr1529 bool = false
			yyq1529[0] = x.Privileged != false
			yyq1529[1] = len(x.Capabilities) != 0
			yyq1529[2] = len(x.Volumes) != 0
			yyq1529[3] = x.HostNetwork != false
			yyq1529[4] = len(x.HostPorts) != 0
			yyq1529[5] = x.HostPID != false
			yyq1529[6] = x.HostIPC != false
			yyq1529[7] = true
			yyq1529[8] = true
			var yynn1529 int
			if yyr1529 || yy2arr1529 {
				r.EncodeArrayStart(9)
			} else {
				yynn1529 = 0
				for _, b := range yyq1529 {
					if b {
						yynn1529++
					}
				}
				r.EncodeMapStart(yynn1529)
				yynn1529 = 0
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[0] {
					yym1531 := z.EncBinary()
					_ = yym1531
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1529[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("privileged"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1532 := z.EncBinary()
					_ = yym1532
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[1] {
					if x.Capabilities == nil {
						r.EncodeNil()
					} else {
						yym1534 := z.EncBinary()
						_ = yym1534
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.Capabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("capabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Capabilities == nil {
						r.EncodeNil()
					} else {
						yym1535 := z.EncBinary()
						_ = yym1535
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.Capabilities), e)
						}
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[2] {
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1537 := z.EncBinary()
						_ = yym1537
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("volumes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1538 := z.EncBinary()
						_ = yym1538
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[3] {
					yym1540 := z.EncBinary()
					_ = yym1540
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1529[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1541 := z.EncBinary()
					_ = yym1541
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[4] {
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1543 := z.EncBinary()
						_ = yym1543
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1544 := z.EncBinary()
						_ = yym1544
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[5] {
					yym1546 := z.EncBinary()
					_ = yym1546
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1529[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1547 := z.EncBinary()
					_ = yym1547
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[6] {
					yym1549 := z.EncBinary()
					_ = yym1549
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1529[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1550 := z.EncBinary()
					_ = yym1550
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[7] {
					yy1552 := &x.SELinuxContext
					yy1552.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("seLinuxContext"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1553 := &x.SELinuxContext
					yy1553.CodecEncodeSelf(e)
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[8] {
					yy1555 := &x.RunAsUser
					yy1555.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1556 := &x.RunAsUser
					yy1556.CodecEncodeSelf(e)
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1559Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1559Slc
	var yyhl1559 bool = l >= 0
	for yyj1559 := 0; ; yyj1559++ {
		if yyhl1559 {
			if yyj1559 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1559Slc = r.DecodeBytes(yys1559Slc, true, true)
		yys1559 := string(yys1559Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1559 {
		case "privileged":
			if r.TryDecodeAsNil() {
				x.Privileged = false
			} else {
				x.Privileged = bool(r.DecodeBool())
			}
		case "capabilities":
			if r.TryDecodeAsNil() {
				x.Capabilities = nil
			} else {
				yyv1561 := &x.Capabilities
				yym1562 := z.DecBinary()
				_ = yym1562
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1561), d)
				}
			}
		case "volumes":
			if r.TryDecodeAsNil() {
				x.Volumes = nil
			} else {
				yyv1563 := &x.Volumes
				yym1564 := z.DecBinary()
				_ = yym1564
				if false {
				} else {
					h.decSliceFSType((*[]FSType)(yyv1563), d)
				}
			}
		case "hostNetwork":
			if r.TryDecodeAsNil() {
				x.HostNetwork = false
			} else {
				x.HostNetwork = bool(r.DecodeBool())
			}
		case "hostPorts":
			if r.TryDecodeAsNil() {
				x.HostPorts = nil
			} else {
				yyv1566 := &x.HostPorts
				yym1567 := z.DecBinary()
				_ = yym1567
				if false {
				} else {
					h.decSliceHostPortRange((*[]HostPortRange)(yyv1566), d)
				}
			}
		case "hostPID":
			if r.TryDecodeAsNil() {
				x.HostPID = false
			} else {
				x.HostPID = bool(r.DecodeBool())
			}
		case "hostIPC":
			if r.TryDecodeAsNil() {
				x.HostIPC = false
			} else {
				x.HostIPC = bool(r.DecodeBool())
			}
		case "seLinuxContext":
			if r.TryDecodeAsNil() {
				x.SELinuxContext = SELinuxContextStrategyOptions{}
			} else {
				yyv1570 := &x.SELinuxContext
				yyv1570.CodecDecodeSelf(d)
			}
		case "runAsUser":
			if r.TryDecodeAsNil() {
				x.RunAsUser = RunAsUserStrategyOptions{}
			} else {
				yyv1571 := &x.RunAsUser
				yyv1571.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1559)
		} // end switch yys1559
	} // end for yyj1559
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1572 int
	var yyb1572 bool
	var yyhl1572 bool = l >= 0
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Privileged = false
	} else {
		x.Privileged = bool(r.DecodeBool())
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Capabilities = nil
	} else {
		yyv1574 := &x.Capabilities
		yym1575 := z.DecBinary()
		_ = yym1575
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1574), d)
		}
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Volumes = nil
	} else {
		yyv1576 := &x.Volumes
		yym1577 := z.DecBinary()
		_ = yym1577
		if false {
		} else {
			h.decSliceFSType((*[]FSType)(yyv1576), d)
		}
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostNetwork = false
	} else {
		x.HostNetwork = bool(r.DecodeBool())
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPorts = nil
	} else {
		yyv1579 := &x.HostPorts
		yym1580 := z.DecBinary()
		_ = yym1580
		if false {
		} else {
			h.decSliceHostPortRange((*[]HostPortRange)(yyv1579), d)
		}
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPID = false
	} else {
		x.HostPID = bool(r.DecodeBool())
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostIPC = false
	} else {
		x.HostIPC = bool(r.DecodeBool())
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SELinuxContext = SELinuxContextStrategyOptions{}
	} else {
		yyv1583 := &x.SELinuxContext
		yyv1583.CodecDecodeSelf(d)
	}
	yyj1572++
	if yyhl1572 {
		yyb1572 = yyj1572 > l
	} else {
		yyb1572 = r.CheckBreak()
	}
	if yyb1572 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RunAsUser = RunAsUserStrategyOptions{}
	} else {
		yyv1584 := &x.RunAsUser
		yyv1584.CodecDecodeSelf(d)
	}
	for {
		yyj1572++
		if yyhl1572 {
			yyb1572 = yyj1572 > l
		} else {
			yyb1572 = r.CheckBreak()
		}
		if yyb1572 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1572-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1587 := z.EncBinary()
		_ = yym1587
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1588 := !z.EncBinary()
			yy2arr1588 := z.EncBasicHandle().StructToArray
			var yyq1588 [2]bool
			_, _, _ = yysep1588, yyq1588, yy2arr1588
			const yyr1588 bool = false
			var yynn1588 int
			if yyr1588 || yy2arr1588 {
				r.EncodeArrayStart(2)
			} else {
				yynn1588 = 2
				for _, b := range yyq1588 {
					if b {
						yynn1588++
					}
				}
				r.EncodeMapStart(yynn1588)
				yynn1588 = 0
			}
			if yyr1588 || yy2arr1588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1590 := z.EncBinary()
				_ = yym1590
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1591 := z.EncBinary()
				_ = yym1591
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1588 || yy2arr1588 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1593 := z.EncBinary()
				_ = yym1593
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1594 := z.EncBinary()
				_ = yym1594
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1588 || yy2arr1588 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1597Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1597Slc
	var yyhl1597 bool = l >= 0
	for yyj1597 := 0; ; yyj1597++ {
		if yyhl1597 {
			if yyj1597 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1597Slc = r.DecodeBytes(yys1597Slc, true, true)
		yys1597 := string(yys1597Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1597 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int32(r.DecodeInt(32))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1597)
		} // end switch yys1597
	} // end for yyj1597
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

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

func (x *SELinuxContextStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1603 := z.EncBinary()
		_ = yym1603
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1604 := !z.EncBinary()
			yy2arr1604 := z.EncBasicHandle().StructToArray
			var yyq1604 [2]bool
			_, _, _ = yysep1604, yyq1604, yy2arr1604
			const yyr1604 bool = false
			yyq1604[1] = x.SELinuxOptions != nil
			var yynn1604 int
			if yyr1604 || yy2arr1604 {
				r.EncodeArrayStart(2)
			} else {
				yynn1604 = 1
				for _, b := range yyq1604 {
					if b {
						yynn1604++
					}
				}
				r.EncodeMapStart(yynn1604)
				yynn1604 = 0
			}
			if yyr1604 || yy2arr1604 {
				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 yyr1604 || yy2arr1604 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1604[1] {
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1604[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1604 || yy2arr1604 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *SELinuxContextStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1609Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1609Slc
	var yyhl1609 bool = l >= 0
	for yyj1609 := 0; ; yyj1609++ {
		if yyhl1609 {
			if yyj1609 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1609Slc = r.DecodeBytes(yys1609Slc, true, true)
		yys1609 := string(yys1609Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1609 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = SELinuxContextStrategy(r.DecodeString())
			}
		case "seLinuxOptions":
			if r.TryDecodeAsNil() {
				if x.SELinuxOptions != nil {
					x.SELinuxOptions = nil
				}
			} else {
				if x.SELinuxOptions == nil {
					x.SELinuxOptions = new(pkg2_v1.SELinuxOptions)
				}
				x.SELinuxOptions.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1609)
		} // end switch yys1609
	} // end for yyj1609
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SELinuxContextStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1612 int
	var yyb1612 bool
	var yyhl1612 bool = l >= 0
	yyj1612++
	if yyhl1612 {
		yyb1612 = yyj1612 > l
	} else {
		yyb1612 = r.CheckBreak()
	}
	if yyb1612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = SELinuxContextStrategy(r.DecodeString())
	}
	yyj1612++
	if yyhl1612 {
		yyb1612 = yyj1612 > l
	} else {
		yyb1612 = r.CheckBreak()
	}
	if yyb1612 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.SELinuxOptions != nil {
			x.SELinuxOptions = nil
		}
	} else {
		if x.SELinuxOptions == nil {
			x.SELinuxOptions = new(pkg2_v1.SELinuxOptions)
		}
		x.SELinuxOptions.CodecDecodeSelf(d)
	}
	for {
		yyj1612++
		if yyhl1612 {
			yyb1612 = yyj1612 > l
		} else {
			yyb1612 = r.CheckBreak()
		}
		if yyb1612 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1612-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1617 := z.EncBinary()
		_ = yym1617
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1618 := !z.EncBinary()
			yy2arr1618 := z.EncBasicHandle().StructToArray
			var yyq1618 [2]bool
			_, _, _ = yysep1618, yyq1618, yy2arr1618
			const yyr1618 bool = false
			yyq1618[1] = len(x.Ranges) != 0
			var yynn1618 int
			if yyr1618 || yy2arr1618 {
				r.EncodeArrayStart(2)
			} else {
				yynn1618 = 1
				for _, b := range yyq1618 {
					if b {
						yynn1618++
					}
				}
				r.EncodeMapStart(yynn1618)
				yynn1618 = 0
			}
			if yyr1618 || yy2arr1618 {
				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 yyr1618 || yy2arr1618 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1618[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1621 := z.EncBinary()
						_ = yym1621
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1618[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1622 := z.EncBinary()
						_ = yym1622
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1618 || yy2arr1618 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1625Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1625Slc
	var yyhl1625 bool = l >= 0
	for yyj1625 := 0; ; yyj1625++ {
		if yyhl1625 {
			if yyj1625 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1625Slc = r.DecodeBytes(yys1625Slc, true, true)
		yys1625 := string(yys1625Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1625 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = RunAsUserStrategy(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1627 := &x.Ranges
				yym1628 := z.DecBinary()
				_ = yym1628
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1627), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1625)
		} // end switch yys1625
	} // end for yyj1625
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1629 int
	var yyb1629 bool
	var yyhl1629 bool = l >= 0
	yyj1629++
	if yyhl1629 {
		yyb1629 = yyj1629 > l
	} else {
		yyb1629 = r.CheckBreak()
	}
	if yyb1629 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = RunAsUserStrategy(r.DecodeString())
	}
	yyj1629++
	if yyhl1629 {
		yyb1629 = yyj1629 > l
	} else {
		yyb1629 = r.CheckBreak()
	}
	if yyb1629 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1631 := &x.Ranges
		yym1632 := z.DecBinary()
		_ = yym1632
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1631), d)
		}
	}
	for {
		yyj1629++
		if yyhl1629 {
			yyb1629 = yyj1629 > l
		} else {
			yyb1629 = r.CheckBreak()
		}
		if yyb1629 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1629-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1633 := z.EncBinary()
		_ = yym1633
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1634 := !z.EncBinary()
			yy2arr1634 := z.EncBasicHandle().StructToArray
			var yyq1634 [2]bool
			_, _, _ = yysep1634, yyq1634, yy2arr1634
			const yyr1634 bool = false
			var yynn1634 int
			if yyr1634 || yy2arr1634 {
				r.EncodeArrayStart(2)
			} else {
				yynn1634 = 2
				for _, b := range yyq1634 {
					if b {
						yynn1634++
					}
				}
				r.EncodeMapStart(yynn1634)
				yynn1634 = 0
			}
			if yyr1634 || yy2arr1634 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1636 := z.EncBinary()
				_ = yym1636
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1637 := z.EncBinary()
				_ = yym1637
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1634 || yy2arr1634 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1639 := z.EncBinary()
				_ = yym1639
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1640 := z.EncBinary()
				_ = yym1640
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1634 || yy2arr1634 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1643Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1643Slc
	var yyhl1643 bool = l >= 0
	for yyj1643 := 0; ; yyj1643++ {
		if yyhl1643 {
			if yyj1643 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1643Slc = r.DecodeBytes(yys1643Slc, true, true)
		yys1643 := string(yys1643Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1643 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int64(r.DecodeInt(64))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1643)
		} // end switch yys1643
	} // end for yyj1643
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IDRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1646 int
	var yyb1646 bool
	var yyhl1646 bool = l >= 0
	yyj1646++
	if yyhl1646 {
		yyb1646 = yyj1646 > l
	} else {
		yyb1646 = r.CheckBreak()
	}
	if yyb1646 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int64(r.DecodeInt(64))
	}
	yyj1646++
	if yyhl1646 {
		yyb1646 = yyj1646 > l
	} else {
		yyb1646 = r.CheckBreak()
	}
	if yyb1646 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int64(r.DecodeInt(64))
	}
	for {
		yyj1646++
		if yyhl1646 {
			yyb1646 = yyj1646 > l
		} else {
			yyb1646 = r.CheckBreak()
		}
		if yyb1646 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1646-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1651 := z.EncBinary()
		_ = yym1651
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1652 := !z.EncBinary()
			yy2arr1652 := z.EncBasicHandle().StructToArray
			var yyq1652 [4]bool
			_, _, _ = yysep1652, yyq1652, yy2arr1652
			const yyr1652 bool = false
			yyq1652[0] = true
			yyq1652[2] = x.Kind != ""
			yyq1652[3] = x.APIVersion != ""
			var yynn1652 int
			if yyr1652 || yy2arr1652 {
				r.EncodeArrayStart(4)
			} else {
				yynn1652 = 1
				for _, b := range yyq1652 {
					if b {
						yynn1652++
					}
				}
				r.EncodeMapStart(yynn1652)
				yynn1652 = 0
			}
			if yyr1652 || yy2arr1652 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1652[0] {
					yy1654 := &x.ListMeta
					yym1655 := z.EncBinary()
					_ = yym1655
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1654) {
					} else {
						z.EncFallback(yy1654)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1652[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1656 := &x.ListMeta
					yym1657 := z.EncBinary()
					_ = yym1657
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1656) {
					} else {
						z.EncFallback(yy1656)
					}
				}
			}
			if yyr1652 || yy2arr1652 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1659 := z.EncBinary()
					_ = yym1659
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(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 {
					yym1660 := z.EncBinary()
					_ = yym1660
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			}
			if yyr1652 || yy2arr1652 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1652[2] {
					yym1662 := z.EncBinary()
					_ = yym1662
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1652[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1663 := z.EncBinary()
					_ = yym1663
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1652 || yy2arr1652 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1652[3] {
					yym1665 := z.EncBinary()
					_ = yym1665
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1652[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1666 := z.EncBinary()
					_ = yym1666
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1652 || yy2arr1652 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1669Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1669Slc
	var yyhl1669 bool = l >= 0
	for yyj1669 := 0; ; yyj1669++ {
		if yyhl1669 {
			if yyj1669 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1669Slc = r.DecodeBytes(yys1669Slc, true, true)
		yys1669 := string(yys1669Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1669 {
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1670 := &x.ListMeta
				yym1671 := z.DecBinary()
				_ = yym1671
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1670) {
				} else {
					z.DecFallback(yyv1670, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1672 := &x.Items
				yym1673 := z.DecBinary()
				_ = yym1673
				if false {
				} else {
					h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1672), d)
				}
			}
		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, yys1669)
		} // end switch yys1669
	} // end for yyj1669
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1676 int
	var yyb1676 bool
	var yyhl1676 bool = l >= 0
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1677 := &x.ListMeta
		yym1678 := z.DecBinary()
		_ = yym1678
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1677) {
		} else {
			z.DecFallback(yyv1677, false)
		}
	}
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1679 := &x.Items
		yym1680 := z.DecBinary()
		_ = yym1680
		if false {
		} else {
			h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1679), d)
		}
	}
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj1676++
		if yyhl1676 {
			yyb1676 = yyj1676 > l
		} else {
			yyb1676 = r.CheckBreak()
		}
		if yyb1676 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1676-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

	yyv1685 := *v
	yyh1685, yyl1685 := z.DecSliceHelperStart()
	var yyc1685 bool
	if yyl1685 == 0 {
		if yyv1685 == nil {
			yyv1685 = []CustomMetricTarget{}
			yyc1685 = true
		} else if len(yyv1685) != 0 {
			yyv1685 = yyv1685[:0]
			yyc1685 = true
		}
	} else if yyl1685 > 0 {
		var yyrr1685, yyrl1685 int
		var yyrt1685 bool
		if yyl1685 > cap(yyv1685) {

			yyrg1685 := len(yyv1685) > 0
			yyv21685 := yyv1685
			yyrl1685, yyrt1685 = z.DecInferLen(yyl1685, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1685 {
				if yyrl1685 <= cap(yyv1685) {
					yyv1685 = yyv1685[:yyrl1685]
				} else {
					yyv1685 = make([]CustomMetricTarget, yyrl1685)
				}
			} else {
				yyv1685 = make([]CustomMetricTarget, yyrl1685)
			}
			yyc1685 = true
			yyrr1685 = len(yyv1685)
			if yyrg1685 {
				copy(yyv1685, yyv21685)
			}
		} else if yyl1685 != len(yyv1685) {
			yyv1685 = yyv1685[:yyl1685]
			yyc1685 = true
		}
		yyj1685 := 0
		for ; yyj1685 < yyrr1685; yyj1685++ {
			yyh1685.ElemContainerState(yyj1685)
			if r.TryDecodeAsNil() {
				yyv1685[yyj1685] = CustomMetricTarget{}
			} else {
				yyv1686 := &yyv1685[yyj1685]
				yyv1686.CodecDecodeSelf(d)
			}

		}
		if yyrt1685 {
			for ; yyj1685 < yyl1685; yyj1685++ {
				yyv1685 = append(yyv1685, CustomMetricTarget{})
				yyh1685.ElemContainerState(yyj1685)
				if r.TryDecodeAsNil() {
					yyv1685[yyj1685] = CustomMetricTarget{}
				} else {
					yyv1687 := &yyv1685[yyj1685]
					yyv1687.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1685 >= len(yyv1685) {
				yyv1685 = append(yyv1685, CustomMetricTarget{}) // var yyz1685 CustomMetricTarget
				yyc1685 = true
			}
			yyh1685.ElemContainerState(yyj1685)
			if yyj1685 < len(yyv1685) {
				if r.TryDecodeAsNil() {
					yyv1685[yyj1685] = CustomMetricTarget{}
				} else {
					yyv1688 := &yyv1685[yyj1685]
					yyv1688.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1685 < len(yyv1685) {
			yyv1685 = yyv1685[:yyj1685]
			yyc1685 = true
		} else if yyj1685 == 0 && yyv1685 == nil {
			yyv1685 = []CustomMetricTarget{}
			yyc1685 = true
		}
	}
	yyh1685.End()
	if yyc1685 {
		*v = yyv1685
	}
}

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

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

	yyv1691 := *v
	yyh1691, yyl1691 := z.DecSliceHelperStart()
	var yyc1691 bool
	if yyl1691 == 0 {
		if yyv1691 == nil {
			yyv1691 = []CustomMetricCurrentStatus{}
			yyc1691 = true
		} else if len(yyv1691) != 0 {
			yyv1691 = yyv1691[:0]
			yyc1691 = true
		}
	} else if yyl1691 > 0 {
		var yyrr1691, yyrl1691 int
		var yyrt1691 bool
		if yyl1691 > cap(yyv1691) {

			yyrg1691 := len(yyv1691) > 0
			yyv21691 := yyv1691
			yyrl1691, yyrt1691 = z.DecInferLen(yyl1691, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1691 {
				if yyrl1691 <= cap(yyv1691) {
					yyv1691 = yyv1691[:yyrl1691]
				} else {
					yyv1691 = make([]CustomMetricCurrentStatus, yyrl1691)
				}
			} else {
				yyv1691 = make([]CustomMetricCurrentStatus, yyrl1691)
			}
			yyc1691 = true
			yyrr1691 = len(yyv1691)
			if yyrg1691 {
				copy(yyv1691, yyv21691)
			}
		} else if yyl1691 != len(yyv1691) {
			yyv1691 = yyv1691[:yyl1691]
			yyc1691 = true
		}
		yyj1691 := 0
		for ; yyj1691 < yyrr1691; yyj1691++ {
			yyh1691.ElemContainerState(yyj1691)
			if r.TryDecodeAsNil() {
				yyv1691[yyj1691] = CustomMetricCurrentStatus{}
			} else {
				yyv1692 := &yyv1691[yyj1691]
				yyv1692.CodecDecodeSelf(d)
			}

		}
		if yyrt1691 {
			for ; yyj1691 < yyl1691; yyj1691++ {
				yyv1691 = append(yyv1691, CustomMetricCurrentStatus{})
				yyh1691.ElemContainerState(yyj1691)
				if r.TryDecodeAsNil() {
					yyv1691[yyj1691] = CustomMetricCurrentStatus{}
				} else {
					yyv1693 := &yyv1691[yyj1691]
					yyv1693.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1691 >= len(yyv1691) {
				yyv1691 = append(yyv1691, CustomMetricCurrentStatus{}) // var yyz1691 CustomMetricCurrentStatus
				yyc1691 = true
			}
			yyh1691.ElemContainerState(yyj1691)
			if yyj1691 < len(yyv1691) {
				if r.TryDecodeAsNil() {
					yyv1691[yyj1691] = CustomMetricCurrentStatus{}
				} else {
					yyv1694 := &yyv1691[yyj1691]
					yyv1694.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1691 < len(yyv1691) {
			yyv1691 = yyv1691[:yyj1691]
			yyc1691 = true
		} else if yyj1691 == 0 && yyv1691 == nil {
			yyv1691 = []CustomMetricCurrentStatus{}
			yyc1691 = true
		}
	}
	yyh1691.End()
	if yyc1691 {
		*v = yyv1691
	}
}

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

	yyv1697 := *v
	yyh1697, yyl1697 := z.DecSliceHelperStart()
	var yyc1697 bool
	if yyl1697 == 0 {
		if yyv1697 == nil {
			yyv1697 = []HorizontalPodAutoscaler{}
			yyc1697 = true
		} else if len(yyv1697) != 0 {
			yyv1697 = yyv1697[:0]
			yyc1697 = true
		}
	} else if yyl1697 > 0 {
		var yyrr1697, yyrl1697 int
		var yyrt1697 bool
		if yyl1697 > cap(yyv1697) {

			yyrg1697 := len(yyv1697) > 0
			yyv21697 := yyv1697
			yyrl1697, yyrt1697 = z.DecInferLen(yyl1697, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1697 {
				if yyrl1697 <= cap(yyv1697) {
					yyv1697 = yyv1697[:yyrl1697]
				} else {
					yyv1697 = make([]HorizontalPodAutoscaler, yyrl1697)
				}
			} else {
				yyv1697 = make([]HorizontalPodAutoscaler, yyrl1697)
			}
			yyc1697 = true
			yyrr1697 = len(yyv1697)
			if yyrg1697 {
				copy(yyv1697, yyv21697)
			}
		} else if yyl1697 != len(yyv1697) {
			yyv1697 = yyv1697[:yyl1697]
			yyc1697 = true
		}
		yyj1697 := 0
		for ; yyj1697 < yyrr1697; yyj1697++ {
			yyh1697.ElemContainerState(yyj1697)
			if r.TryDecodeAsNil() {
				yyv1697[yyj1697] = HorizontalPodAutoscaler{}
			} else {
				yyv1698 := &yyv1697[yyj1697]
				yyv1698.CodecDecodeSelf(d)
			}

		}
		if yyrt1697 {
			for ; yyj1697 < yyl1697; yyj1697++ {
				yyv1697 = append(yyv1697, HorizontalPodAutoscaler{})
				yyh1697.ElemContainerState(yyj1697)
				if r.TryDecodeAsNil() {
					yyv1697[yyj1697] = HorizontalPodAutoscaler{}
				} else {
					yyv1699 := &yyv1697[yyj1697]
					yyv1699.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1697 >= len(yyv1697) {
				yyv1697 = append(yyv1697, HorizontalPodAutoscaler{}) // var yyz1697 HorizontalPodAutoscaler
				yyc1697 = true
			}
			yyh1697.ElemContainerState(yyj1697)
			if yyj1697 < len(yyv1697) {
				if r.TryDecodeAsNil() {
					yyv1697[yyj1697] = HorizontalPodAutoscaler{}
				} else {
					yyv1700 := &yyv1697[yyj1697]
					yyv1700.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1697 < len(yyv1697) {
			yyv1697 = yyv1697[:yyj1697]
			yyc1697 = true
		} else if yyj1697 == 0 && yyv1697 == nil {
			yyv1697 = []HorizontalPodAutoscaler{}
			yyc1697 = true
		}
	}
	yyh1697.End()
	if yyc1697 {
		*v = yyv1697
	}
}

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

	yyv1703 := *v
	yyh1703, yyl1703 := z.DecSliceHelperStart()
	var yyc1703 bool
	if yyl1703 == 0 {
		if yyv1703 == nil {
			yyv1703 = []APIVersion{}
			yyc1703 = true
		} else if len(yyv1703) != 0 {
			yyv1703 = yyv1703[:0]
			yyc1703 = true
		}
	} else if yyl1703 > 0 {
		var yyrr1703, yyrl1703 int
		var yyrt1703 bool
		if yyl1703 > cap(yyv1703) {

			yyrg1703 := len(yyv1703) > 0
			yyv21703 := yyv1703
			yyrl1703, yyrt1703 = z.DecInferLen(yyl1703, z.DecBasicHandle().MaxInitLen, 32)
			if yyrt1703 {
				if yyrl1703 <= cap(yyv1703) {
					yyv1703 = yyv1703[:yyrl1703]
				} else {
					yyv1703 = make([]APIVersion, yyrl1703)
				}
			} else {
				yyv1703 = make([]APIVersion, yyrl1703)
			}
			yyc1703 = true
			yyrr1703 = len(yyv1703)
			if yyrg1703 {
				copy(yyv1703, yyv21703)
			}
		} else if yyl1703 != len(yyv1703) {
			yyv1703 = yyv1703[:yyl1703]
			yyc1703 = true
		}
		yyj1703 := 0
		for ; yyj1703 < yyrr1703; yyj1703++ {
			yyh1703.ElemContainerState(yyj1703)
			if r.TryDecodeAsNil() {
				yyv1703[yyj1703] = APIVersion{}
			} else {
				yyv1704 := &yyv1703[yyj1703]
				yyv1704.CodecDecodeSelf(d)
			}

		}
		if yyrt1703 {
			for ; yyj1703 < yyl1703; yyj1703++ {
				yyv1703 = append(yyv1703, APIVersion{})
				yyh1703.ElemContainerState(yyj1703)
				if r.TryDecodeAsNil() {
					yyv1703[yyj1703] = APIVersion{}
				} else {
					yyv1705 := &yyv1703[yyj1703]
					yyv1705.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1703 >= len(yyv1703) {
				yyv1703 = append(yyv1703, APIVersion{}) // var yyz1703 APIVersion
				yyc1703 = true
			}
			yyh1703.ElemContainerState(yyj1703)
			if yyj1703 < len(yyv1703) {
				if r.TryDecodeAsNil() {
					yyv1703[yyj1703] = APIVersion{}
				} else {
					yyv1706 := &yyv1703[yyj1703]
					yyv1706.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1703 < len(yyv1703) {
			yyv1703 = yyv1703[:yyj1703]
			yyc1703 = true
		} else if yyj1703 == 0 && yyv1703 == nil {
			yyv1703 = []APIVersion{}
			yyc1703 = true
		}
	}
	yyh1703.End()
	if yyc1703 {
		*v = yyv1703
	}
}

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

	yyv1709 := *v
	yyh1709, yyl1709 := z.DecSliceHelperStart()
	var yyc1709 bool
	if yyl1709 == 0 {
		if yyv1709 == nil {
			yyv1709 = []ThirdPartyResource{}
			yyc1709 = true
		} else if len(yyv1709) != 0 {
			yyv1709 = yyv1709[:0]
			yyc1709 = true
		}
	} else if yyl1709 > 0 {
		var yyrr1709, yyrl1709 int
		var yyrt1709 bool
		if yyl1709 > cap(yyv1709) {

			yyrg1709 := len(yyv1709) > 0
			yyv21709 := yyv1709
			yyrl1709, yyrt1709 = z.DecInferLen(yyl1709, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1709 {
				if yyrl1709 <= cap(yyv1709) {
					yyv1709 = yyv1709[:yyrl1709]
				} else {
					yyv1709 = make([]ThirdPartyResource, yyrl1709)
				}
			} else {
				yyv1709 = make([]ThirdPartyResource, yyrl1709)
			}
			yyc1709 = true
			yyrr1709 = len(yyv1709)
			if yyrg1709 {
				copy(yyv1709, yyv21709)
			}
		} else if yyl1709 != len(yyv1709) {
			yyv1709 = yyv1709[:yyl1709]
			yyc1709 = true
		}
		yyj1709 := 0
		for ; yyj1709 < yyrr1709; yyj1709++ {
			yyh1709.ElemContainerState(yyj1709)
			if r.TryDecodeAsNil() {
				yyv1709[yyj1709] = ThirdPartyResource{}
			} else {
				yyv1710 := &yyv1709[yyj1709]
				yyv1710.CodecDecodeSelf(d)
			}

		}
		if yyrt1709 {
			for ; yyj1709 < yyl1709; yyj1709++ {
				yyv1709 = append(yyv1709, ThirdPartyResource{})
				yyh1709.ElemContainerState(yyj1709)
				if r.TryDecodeAsNil() {
					yyv1709[yyj1709] = ThirdPartyResource{}
				} else {
					yyv1711 := &yyv1709[yyj1709]
					yyv1711.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1709 >= len(yyv1709) {
				yyv1709 = append(yyv1709, ThirdPartyResource{}) // var yyz1709 ThirdPartyResource
				yyc1709 = true
			}
			yyh1709.ElemContainerState(yyj1709)
			if yyj1709 < len(yyv1709) {
				if r.TryDecodeAsNil() {
					yyv1709[yyj1709] = ThirdPartyResource{}
				} else {
					yyv1712 := &yyv1709[yyj1709]
					yyv1712.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1709 < len(yyv1709) {
			yyv1709 = yyv1709[:yyj1709]
			yyc1709 = true
		} else if yyj1709 == 0 && yyv1709 == nil {
			yyv1709 = []ThirdPartyResource{}
			yyc1709 = true
		}
	}
	yyh1709.End()
	if yyc1709 {
		*v = yyv1709
	}
}

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

	yyv1715 := *v
	yyh1715, yyl1715 := z.DecSliceHelperStart()
	var yyc1715 bool
	if yyl1715 == 0 {
		if yyv1715 == nil {
			yyv1715 = []Deployment{}
			yyc1715 = true
		} else if len(yyv1715) != 0 {
			yyv1715 = yyv1715[:0]
			yyc1715 = true
		}
	} else if yyl1715 > 0 {
		var yyrr1715, yyrl1715 int
		var yyrt1715 bool
		if yyl1715 > cap(yyv1715) {

			yyrg1715 := len(yyv1715) > 0
			yyv21715 := yyv1715
			yyrl1715, yyrt1715 = z.DecInferLen(yyl1715, z.DecBasicHandle().MaxInitLen, 632)
			if yyrt1715 {
				if yyrl1715 <= cap(yyv1715) {
					yyv1715 = yyv1715[:yyrl1715]
				} else {
					yyv1715 = make([]Deployment, yyrl1715)
				}
			} else {
				yyv1715 = make([]Deployment, yyrl1715)
			}
			yyc1715 = true
			yyrr1715 = len(yyv1715)
			if yyrg1715 {
				copy(yyv1715, yyv21715)
			}
		} else if yyl1715 != len(yyv1715) {
			yyv1715 = yyv1715[:yyl1715]
			yyc1715 = true
		}
		yyj1715 := 0
		for ; yyj1715 < yyrr1715; yyj1715++ {
			yyh1715.ElemContainerState(yyj1715)
			if r.TryDecodeAsNil() {
				yyv1715[yyj1715] = Deployment{}
			} else {
				yyv1716 := &yyv1715[yyj1715]
				yyv1716.CodecDecodeSelf(d)
			}

		}
		if yyrt1715 {
			for ; yyj1715 < yyl1715; yyj1715++ {
				yyv1715 = append(yyv1715, Deployment{})
				yyh1715.ElemContainerState(yyj1715)
				if r.TryDecodeAsNil() {
					yyv1715[yyj1715] = Deployment{}
				} else {
					yyv1717 := &yyv1715[yyj1715]
					yyv1717.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1715 >= len(yyv1715) {
				yyv1715 = append(yyv1715, Deployment{}) // var yyz1715 Deployment
				yyc1715 = true
			}
			yyh1715.ElemContainerState(yyj1715)
			if yyj1715 < len(yyv1715) {
				if r.TryDecodeAsNil() {
					yyv1715[yyj1715] = Deployment{}
				} else {
					yyv1718 := &yyv1715[yyj1715]
					yyv1718.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1715 < len(yyv1715) {
			yyv1715 = yyv1715[:yyj1715]
			yyc1715 = true
		} else if yyj1715 == 0 && yyv1715 == nil {
			yyv1715 = []Deployment{}
			yyc1715 = true
		}
	}
	yyh1715.End()
	if yyc1715 {
		*v = yyv1715
	}
}

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

	yyv1721 := *v
	yyh1721, yyl1721 := z.DecSliceHelperStart()
	var yyc1721 bool
	if yyl1721 == 0 {
		if yyv1721 == nil {
			yyv1721 = []DaemonSet{}
			yyc1721 = true
		} else if len(yyv1721) != 0 {
			yyv1721 = yyv1721[:0]
			yyc1721 = true
		}
	} else if yyl1721 > 0 {
		var yyrr1721, yyrl1721 int
		var yyrt1721 bool
		if yyl1721 > cap(yyv1721) {

			yyrg1721 := len(yyv1721) > 0
			yyv21721 := yyv1721
			yyrl1721, yyrt1721 = z.DecInferLen(yyl1721, z.DecBasicHandle().MaxInitLen, 600)
			if yyrt1721 {
				if yyrl1721 <= cap(yyv1721) {
					yyv1721 = yyv1721[:yyrl1721]
				} else {
					yyv1721 = make([]DaemonSet, yyrl1721)
				}
			} else {
				yyv1721 = make([]DaemonSet, yyrl1721)
			}
			yyc1721 = true
			yyrr1721 = len(yyv1721)
			if yyrg1721 {
				copy(yyv1721, yyv21721)
			}
		} else if yyl1721 != len(yyv1721) {
			yyv1721 = yyv1721[:yyl1721]
			yyc1721 = true
		}
		yyj1721 := 0
		for ; yyj1721 < yyrr1721; yyj1721++ {
			yyh1721.ElemContainerState(yyj1721)
			if r.TryDecodeAsNil() {
				yyv1721[yyj1721] = DaemonSet{}
			} else {
				yyv1722 := &yyv1721[yyj1721]
				yyv1722.CodecDecodeSelf(d)
			}

		}
		if yyrt1721 {
			for ; yyj1721 < yyl1721; yyj1721++ {
				yyv1721 = append(yyv1721, DaemonSet{})
				yyh1721.ElemContainerState(yyj1721)
				if r.TryDecodeAsNil() {
					yyv1721[yyj1721] = DaemonSet{}
				} else {
					yyv1723 := &yyv1721[yyj1721]
					yyv1723.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1721 >= len(yyv1721) {
				yyv1721 = append(yyv1721, DaemonSet{}) // var yyz1721 DaemonSet
				yyc1721 = true
			}
			yyh1721.ElemContainerState(yyj1721)
			if yyj1721 < len(yyv1721) {
				if r.TryDecodeAsNil() {
					yyv1721[yyj1721] = DaemonSet{}
				} else {
					yyv1724 := &yyv1721[yyj1721]
					yyv1724.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1721 < len(yyv1721) {
			yyv1721 = yyv1721[:yyj1721]
			yyc1721 = true
		} else if yyj1721 == 0 && yyv1721 == nil {
			yyv1721 = []DaemonSet{}
			yyc1721 = true
		}
	}
	yyh1721.End()
	if yyc1721 {
		*v = yyv1721
	}
}

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

	yyv1727 := *v
	yyh1727, yyl1727 := z.DecSliceHelperStart()
	var yyc1727 bool
	if yyl1727 == 0 {
		if yyv1727 == nil {
			yyv1727 = []ThirdPartyResourceData{}
			yyc1727 = true
		} else if len(yyv1727) != 0 {
			yyv1727 = yyv1727[:0]
			yyc1727 = true
		}
	} else if yyl1727 > 0 {
		var yyrr1727, yyrl1727 int
		var yyrt1727 bool
		if yyl1727 > cap(yyv1727) {

			yyrg1727 := len(yyv1727) > 0
			yyv21727 := yyv1727
			yyrl1727, yyrt1727 = z.DecInferLen(yyl1727, z.DecBasicHandle().MaxInitLen, 216)
			if yyrt1727 {
				if yyrl1727 <= cap(yyv1727) {
					yyv1727 = yyv1727[:yyrl1727]
				} else {
					yyv1727 = make([]ThirdPartyResourceData, yyrl1727)
				}
			} else {
				yyv1727 = make([]ThirdPartyResourceData, yyrl1727)
			}
			yyc1727 = true
			yyrr1727 = len(yyv1727)
			if yyrg1727 {
				copy(yyv1727, yyv21727)
			}
		} else if yyl1727 != len(yyv1727) {
			yyv1727 = yyv1727[:yyl1727]
			yyc1727 = true
		}
		yyj1727 := 0
		for ; yyj1727 < yyrr1727; yyj1727++ {
			yyh1727.ElemContainerState(yyj1727)
			if r.TryDecodeAsNil() {
				yyv1727[yyj1727] = ThirdPartyResourceData{}
			} else {
				yyv1728 := &yyv1727[yyj1727]
				yyv1728.CodecDecodeSelf(d)
			}

		}
		if yyrt1727 {
			for ; yyj1727 < yyl1727; yyj1727++ {
				yyv1727 = append(yyv1727, ThirdPartyResourceData{})
				yyh1727.ElemContainerState(yyj1727)
				if r.TryDecodeAsNil() {
					yyv1727[yyj1727] = ThirdPartyResourceData{}
				} else {
					yyv1729 := &yyv1727[yyj1727]
					yyv1729.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1727 >= len(yyv1727) {
				yyv1727 = append(yyv1727, ThirdPartyResourceData{}) // var yyz1727 ThirdPartyResourceData
				yyc1727 = true
			}
			yyh1727.ElemContainerState(yyj1727)
			if yyj1727 < len(yyv1727) {
				if r.TryDecodeAsNil() {
					yyv1727[yyj1727] = ThirdPartyResourceData{}
				} else {
					yyv1730 := &yyv1727[yyj1727]
					yyv1730.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1727 < len(yyv1727) {
			yyv1727 = yyv1727[:yyj1727]
			yyc1727 = true
		} else if yyj1727 == 0 && yyv1727 == nil {
			yyv1727 = []ThirdPartyResourceData{}
			yyc1727 = true
		}
	}
	yyh1727.End()
	if yyc1727 {
		*v = yyv1727
	}
}

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

	yyv1733 := *v
	yyh1733, yyl1733 := z.DecSliceHelperStart()
	var yyc1733 bool
	if yyl1733 == 0 {
		if yyv1733 == nil {
			yyv1733 = []Job{}
			yyc1733 = true
		} else if len(yyv1733) != 0 {
			yyv1733 = yyv1733[:0]
			yyc1733 = true
		}
	} else if yyl1733 > 0 {
		var yyrr1733, yyrl1733 int
		var yyrt1733 bool
		if yyl1733 > cap(yyv1733) {

			yyrg1733 := len(yyv1733) > 0
			yyv21733 := yyv1733
			yyrl1733, yyrt1733 = z.DecInferLen(yyl1733, z.DecBasicHandle().MaxInitLen, 632)
			if yyrt1733 {
				if yyrl1733 <= cap(yyv1733) {
					yyv1733 = yyv1733[:yyrl1733]
				} else {
					yyv1733 = make([]Job, yyrl1733)
				}
			} else {
				yyv1733 = make([]Job, yyrl1733)
			}
			yyc1733 = true
			yyrr1733 = len(yyv1733)
			if yyrg1733 {
				copy(yyv1733, yyv21733)
			}
		} else if yyl1733 != len(yyv1733) {
			yyv1733 = yyv1733[:yyl1733]
			yyc1733 = true
		}
		yyj1733 := 0
		for ; yyj1733 < yyrr1733; yyj1733++ {
			yyh1733.ElemContainerState(yyj1733)
			if r.TryDecodeAsNil() {
				yyv1733[yyj1733] = Job{}
			} else {
				yyv1734 := &yyv1733[yyj1733]
				yyv1734.CodecDecodeSelf(d)
			}

		}
		if yyrt1733 {
			for ; yyj1733 < yyl1733; yyj1733++ {
				yyv1733 = append(yyv1733, Job{})
				yyh1733.ElemContainerState(yyj1733)
				if r.TryDecodeAsNil() {
					yyv1733[yyj1733] = Job{}
				} else {
					yyv1735 := &yyv1733[yyj1733]
					yyv1735.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1733 >= len(yyv1733) {
				yyv1733 = append(yyv1733, Job{}) // var yyz1733 Job
				yyc1733 = true
			}
			yyh1733.ElemContainerState(yyj1733)
			if yyj1733 < len(yyv1733) {
				if r.TryDecodeAsNil() {
					yyv1733[yyj1733] = Job{}
				} else {
					yyv1736 := &yyv1733[yyj1733]
					yyv1736.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1733 < len(yyv1733) {
			yyv1733 = yyv1733[:yyj1733]
			yyc1733 = true
		} else if yyj1733 == 0 && yyv1733 == nil {
			yyv1733 = []Job{}
			yyc1733 = true
		}
	}
	yyh1733.End()
	if yyc1733 {
		*v = yyv1733
	}
}

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

	yyv1739 := *v
	yyh1739, yyl1739 := z.DecSliceHelperStart()
	var yyc1739 bool
	if yyl1739 == 0 {
		if yyv1739 == nil {
			yyv1739 = []JobCondition{}
			yyc1739 = true
		} else if len(yyv1739) != 0 {
			yyv1739 = yyv1739[:0]
			yyc1739 = true
		}
	} else if yyl1739 > 0 {
		var yyrr1739, yyrl1739 int
		var yyrt1739 bool
		if yyl1739 > cap(yyv1739) {

			yyrg1739 := len(yyv1739) > 0
			yyv21739 := yyv1739
			yyrl1739, yyrt1739 = z.DecInferLen(yyl1739, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1739 {
				if yyrl1739 <= cap(yyv1739) {
					yyv1739 = yyv1739[:yyrl1739]
				} else {
					yyv1739 = make([]JobCondition, yyrl1739)
				}
			} else {
				yyv1739 = make([]JobCondition, yyrl1739)
			}
			yyc1739 = true
			yyrr1739 = len(yyv1739)
			if yyrg1739 {
				copy(yyv1739, yyv21739)
			}
		} else if yyl1739 != len(yyv1739) {
			yyv1739 = yyv1739[:yyl1739]
			yyc1739 = true
		}
		yyj1739 := 0
		for ; yyj1739 < yyrr1739; yyj1739++ {
			yyh1739.ElemContainerState(yyj1739)
			if r.TryDecodeAsNil() {
				yyv1739[yyj1739] = JobCondition{}
			} else {
				yyv1740 := &yyv1739[yyj1739]
				yyv1740.CodecDecodeSelf(d)
			}

		}
		if yyrt1739 {
			for ; yyj1739 < yyl1739; yyj1739++ {
				yyv1739 = append(yyv1739, JobCondition{})
				yyh1739.ElemContainerState(yyj1739)
				if r.TryDecodeAsNil() {
					yyv1739[yyj1739] = JobCondition{}
				} else {
					yyv1741 := &yyv1739[yyj1739]
					yyv1741.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1739 >= len(yyv1739) {
				yyv1739 = append(yyv1739, JobCondition{}) // var yyz1739 JobCondition
				yyc1739 = true
			}
			yyh1739.ElemContainerState(yyj1739)
			if yyj1739 < len(yyv1739) {
				if r.TryDecodeAsNil() {
					yyv1739[yyj1739] = JobCondition{}
				} else {
					yyv1742 := &yyv1739[yyj1739]
					yyv1742.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1739 < len(yyv1739) {
			yyv1739 = yyv1739[:yyj1739]
			yyc1739 = true
		} else if yyj1739 == 0 && yyv1739 == nil {
			yyv1739 = []JobCondition{}
			yyc1739 = true
		}
	}
	yyh1739.End()
	if yyc1739 {
		*v = yyv1739
	}
}

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

	yyv1745 := *v
	yyh1745, yyl1745 := z.DecSliceHelperStart()
	var yyc1745 bool
	if yyl1745 == 0 {
		if yyv1745 == nil {
			yyv1745 = []Ingress{}
			yyc1745 = true
		} else if len(yyv1745) != 0 {
			yyv1745 = yyv1745[:0]
			yyc1745 = true
		}
	} else if yyl1745 > 0 {
		var yyrr1745, yyrl1745 int
		var yyrt1745 bool
		if yyl1745 > cap(yyv1745) {

			yyrg1745 := len(yyv1745) > 0
			yyv21745 := yyv1745
			yyrl1745, yyrt1745 = z.DecInferLen(yyl1745, z.DecBasicHandle().MaxInitLen, 272)
			if yyrt1745 {
				if yyrl1745 <= cap(yyv1745) {
					yyv1745 = yyv1745[:yyrl1745]
				} else {
					yyv1745 = make([]Ingress, yyrl1745)
				}
			} else {
				yyv1745 = make([]Ingress, yyrl1745)
			}
			yyc1745 = true
			yyrr1745 = len(yyv1745)
			if yyrg1745 {
				copy(yyv1745, yyv21745)
			}
		} else if yyl1745 != len(yyv1745) {
			yyv1745 = yyv1745[:yyl1745]
			yyc1745 = true
		}
		yyj1745 := 0
		for ; yyj1745 < yyrr1745; yyj1745++ {
			yyh1745.ElemContainerState(yyj1745)
			if r.TryDecodeAsNil() {
				yyv1745[yyj1745] = Ingress{}
			} else {
				yyv1746 := &yyv1745[yyj1745]
				yyv1746.CodecDecodeSelf(d)
			}

		}
		if yyrt1745 {
			for ; yyj1745 < yyl1745; yyj1745++ {
				yyv1745 = append(yyv1745, Ingress{})
				yyh1745.ElemContainerState(yyj1745)
				if r.TryDecodeAsNil() {
					yyv1745[yyj1745] = Ingress{}
				} else {
					yyv1747 := &yyv1745[yyj1745]
					yyv1747.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1745 >= len(yyv1745) {
				yyv1745 = append(yyv1745, Ingress{}) // var yyz1745 Ingress
				yyc1745 = true
			}
			yyh1745.ElemContainerState(yyj1745)
			if yyj1745 < len(yyv1745) {
				if r.TryDecodeAsNil() {
					yyv1745[yyj1745] = Ingress{}
				} else {
					yyv1748 := &yyv1745[yyj1745]
					yyv1748.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1745 < len(yyv1745) {
			yyv1745 = yyv1745[:yyj1745]
			yyc1745 = true
		} else if yyj1745 == 0 && yyv1745 == nil {
			yyv1745 = []Ingress{}
			yyc1745 = true
		}
	}
	yyh1745.End()
	if yyc1745 {
		*v = yyv1745
	}
}

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

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

	yyv1751 := *v
	yyh1751, yyl1751 := z.DecSliceHelperStart()
	var yyc1751 bool
	if yyl1751 == 0 {
		if yyv1751 == nil {
			yyv1751 = []IngressTLS{}
			yyc1751 = true
		} else if len(yyv1751) != 0 {
			yyv1751 = yyv1751[:0]
			yyc1751 = true
		}
	} else if yyl1751 > 0 {
		var yyrr1751, yyrl1751 int
		var yyrt1751 bool
		if yyl1751 > cap(yyv1751) {

			yyrg1751 := len(yyv1751) > 0
			yyv21751 := yyv1751
			yyrl1751, yyrt1751 = z.DecInferLen(yyl1751, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1751 {
				if yyrl1751 <= cap(yyv1751) {
					yyv1751 = yyv1751[:yyrl1751]
				} else {
					yyv1751 = make([]IngressTLS, yyrl1751)
				}
			} else {
				yyv1751 = make([]IngressTLS, yyrl1751)
			}
			yyc1751 = true
			yyrr1751 = len(yyv1751)
			if yyrg1751 {
				copy(yyv1751, yyv21751)
			}
		} else if yyl1751 != len(yyv1751) {
			yyv1751 = yyv1751[:yyl1751]
			yyc1751 = true
		}
		yyj1751 := 0
		for ; yyj1751 < yyrr1751; yyj1751++ {
			yyh1751.ElemContainerState(yyj1751)
			if r.TryDecodeAsNil() {
				yyv1751[yyj1751] = IngressTLS{}
			} else {
				yyv1752 := &yyv1751[yyj1751]
				yyv1752.CodecDecodeSelf(d)
			}

		}
		if yyrt1751 {
			for ; yyj1751 < yyl1751; yyj1751++ {
				yyv1751 = append(yyv1751, IngressTLS{})
				yyh1751.ElemContainerState(yyj1751)
				if r.TryDecodeAsNil() {
					yyv1751[yyj1751] = IngressTLS{}
				} else {
					yyv1753 := &yyv1751[yyj1751]
					yyv1753.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1751 >= len(yyv1751) {
				yyv1751 = append(yyv1751, IngressTLS{}) // var yyz1751 IngressTLS
				yyc1751 = true
			}
			yyh1751.ElemContainerState(yyj1751)
			if yyj1751 < len(yyv1751) {
				if r.TryDecodeAsNil() {
					yyv1751[yyj1751] = IngressTLS{}
				} else {
					yyv1754 := &yyv1751[yyj1751]
					yyv1754.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1751 < len(yyv1751) {
			yyv1751 = yyv1751[:yyj1751]
			yyc1751 = true
		} else if yyj1751 == 0 && yyv1751 == nil {
			yyv1751 = []IngressTLS{}
			yyc1751 = true
		}
	}
	yyh1751.End()
	if yyc1751 {
		*v = yyv1751
	}
}

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

	yyv1757 := *v
	yyh1757, yyl1757 := z.DecSliceHelperStart()
	var yyc1757 bool
	if yyl1757 == 0 {
		if yyv1757 == nil {
			yyv1757 = []IngressRule{}
			yyc1757 = true
		} else if len(yyv1757) != 0 {
			yyv1757 = yyv1757[:0]
			yyc1757 = true
		}
	} else if yyl1757 > 0 {
		var yyrr1757, yyrl1757 int
		var yyrt1757 bool
		if yyl1757 > cap(yyv1757) {

			yyrg1757 := len(yyv1757) > 0
			yyv21757 := yyv1757
			yyrl1757, yyrt1757 = z.DecInferLen(yyl1757, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1757 {
				if yyrl1757 <= cap(yyv1757) {
					yyv1757 = yyv1757[:yyrl1757]
				} else {
					yyv1757 = make([]IngressRule, yyrl1757)
				}
			} else {
				yyv1757 = make([]IngressRule, yyrl1757)
			}
			yyc1757 = true
			yyrr1757 = len(yyv1757)
			if yyrg1757 {
				copy(yyv1757, yyv21757)
			}
		} else if yyl1757 != len(yyv1757) {
			yyv1757 = yyv1757[:yyl1757]
			yyc1757 = true
		}
		yyj1757 := 0
		for ; yyj1757 < yyrr1757; yyj1757++ {
			yyh1757.ElemContainerState(yyj1757)
			if r.TryDecodeAsNil() {
				yyv1757[yyj1757] = IngressRule{}
			} else {
				yyv1758 := &yyv1757[yyj1757]
				yyv1758.CodecDecodeSelf(d)
			}

		}
		if yyrt1757 {
			for ; yyj1757 < yyl1757; yyj1757++ {
				yyv1757 = append(yyv1757, IngressRule{})
				yyh1757.ElemContainerState(yyj1757)
				if r.TryDecodeAsNil() {
					yyv1757[yyj1757] = IngressRule{}
				} else {
					yyv1759 := &yyv1757[yyj1757]
					yyv1759.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1757 >= len(yyv1757) {
				yyv1757 = append(yyv1757, IngressRule{}) // var yyz1757 IngressRule
				yyc1757 = true
			}
			yyh1757.ElemContainerState(yyj1757)
			if yyj1757 < len(yyv1757) {
				if r.TryDecodeAsNil() {
					yyv1757[yyj1757] = IngressRule{}
				} else {
					yyv1760 := &yyv1757[yyj1757]
					yyv1760.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1757 < len(yyv1757) {
			yyv1757 = yyv1757[:yyj1757]
			yyc1757 = true
		} else if yyj1757 == 0 && yyv1757 == nil {
			yyv1757 = []IngressRule{}
			yyc1757 = true
		}
	}
	yyh1757.End()
	if yyc1757 {
		*v = yyv1757
	}
}

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

	yyv1763 := *v
	yyh1763, yyl1763 := z.DecSliceHelperStart()
	var yyc1763 bool
	if yyl1763 == 0 {
		if yyv1763 == nil {
			yyv1763 = []HTTPIngressPath{}
			yyc1763 = true
		} else if len(yyv1763) != 0 {
			yyv1763 = yyv1763[:0]
			yyc1763 = true
		}
	} else if yyl1763 > 0 {
		var yyrr1763, yyrl1763 int
		var yyrt1763 bool
		if yyl1763 > cap(yyv1763) {

			yyrg1763 := len(yyv1763) > 0
			yyv21763 := yyv1763
			yyrl1763, yyrt1763 = z.DecInferLen(yyl1763, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1763 {
				if yyrl1763 <= cap(yyv1763) {
					yyv1763 = yyv1763[:yyrl1763]
				} else {
					yyv1763 = make([]HTTPIngressPath, yyrl1763)
				}
			} else {
				yyv1763 = make([]HTTPIngressPath, yyrl1763)
			}
			yyc1763 = true
			yyrr1763 = len(yyv1763)
			if yyrg1763 {
				copy(yyv1763, yyv21763)
			}
		} else if yyl1763 != len(yyv1763) {
			yyv1763 = yyv1763[:yyl1763]
			yyc1763 = true
		}
		yyj1763 := 0
		for ; yyj1763 < yyrr1763; yyj1763++ {
			yyh1763.ElemContainerState(yyj1763)
			if r.TryDecodeAsNil() {
				yyv1763[yyj1763] = HTTPIngressPath{}
			} else {
				yyv1764 := &yyv1763[yyj1763]
				yyv1764.CodecDecodeSelf(d)
			}

		}
		if yyrt1763 {
			for ; yyj1763 < yyl1763; yyj1763++ {
				yyv1763 = append(yyv1763, HTTPIngressPath{})
				yyh1763.ElemContainerState(yyj1763)
				if r.TryDecodeAsNil() {
					yyv1763[yyj1763] = HTTPIngressPath{}
				} else {
					yyv1765 := &yyv1763[yyj1763]
					yyv1765.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1763 >= len(yyv1763) {
				yyv1763 = append(yyv1763, HTTPIngressPath{}) // var yyz1763 HTTPIngressPath
				yyc1763 = true
			}
			yyh1763.ElemContainerState(yyj1763)
			if yyj1763 < len(yyv1763) {
				if r.TryDecodeAsNil() {
					yyv1763[yyj1763] = HTTPIngressPath{}
				} else {
					yyv1766 := &yyv1763[yyj1763]
					yyv1766.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1763 < len(yyv1763) {
			yyv1763 = yyv1763[:yyj1763]
			yyc1763 = true
		} else if yyj1763 == 0 && yyv1763 == nil {
			yyv1763 = []HTTPIngressPath{}
			yyc1763 = true
		}
	}
	yyh1763.End()
	if yyc1763 {
		*v = yyv1763
	}
}

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

	yyv1769 := *v
	yyh1769, yyl1769 := z.DecSliceHelperStart()
	var yyc1769 bool
	if yyl1769 == 0 {
		if yyv1769 == nil {
			yyv1769 = []NodeUtilization{}
			yyc1769 = true
		} else if len(yyv1769) != 0 {
			yyv1769 = yyv1769[:0]
			yyc1769 = true
		}
	} else if yyl1769 > 0 {
		var yyrr1769, yyrl1769 int
		var yyrt1769 bool
		if yyl1769 > cap(yyv1769) {

			yyrg1769 := len(yyv1769) > 0
			yyv21769 := yyv1769
			yyrl1769, yyrt1769 = z.DecInferLen(yyl1769, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1769 {
				if yyrl1769 <= cap(yyv1769) {
					yyv1769 = yyv1769[:yyrl1769]
				} else {
					yyv1769 = make([]NodeUtilization, yyrl1769)
				}
			} else {
				yyv1769 = make([]NodeUtilization, yyrl1769)
			}
			yyc1769 = true
			yyrr1769 = len(yyv1769)
			if yyrg1769 {
				copy(yyv1769, yyv21769)
			}
		} else if yyl1769 != len(yyv1769) {
			yyv1769 = yyv1769[:yyl1769]
			yyc1769 = true
		}
		yyj1769 := 0
		for ; yyj1769 < yyrr1769; yyj1769++ {
			yyh1769.ElemContainerState(yyj1769)
			if r.TryDecodeAsNil() {
				yyv1769[yyj1769] = NodeUtilization{}
			} else {
				yyv1770 := &yyv1769[yyj1769]
				yyv1770.CodecDecodeSelf(d)
			}

		}
		if yyrt1769 {
			for ; yyj1769 < yyl1769; yyj1769++ {
				yyv1769 = append(yyv1769, NodeUtilization{})
				yyh1769.ElemContainerState(yyj1769)
				if r.TryDecodeAsNil() {
					yyv1769[yyj1769] = NodeUtilization{}
				} else {
					yyv1771 := &yyv1769[yyj1769]
					yyv1771.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1769 >= len(yyv1769) {
				yyv1769 = append(yyv1769, NodeUtilization{}) // var yyz1769 NodeUtilization
				yyc1769 = true
			}
			yyh1769.ElemContainerState(yyj1769)
			if yyj1769 < len(yyv1769) {
				if r.TryDecodeAsNil() {
					yyv1769[yyj1769] = NodeUtilization{}
				} else {
					yyv1772 := &yyv1769[yyj1769]
					yyv1772.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1769 < len(yyv1769) {
			yyv1769 = yyv1769[:yyj1769]
			yyc1769 = true
		} else if yyj1769 == 0 && yyv1769 == nil {
			yyv1769 = []NodeUtilization{}
			yyc1769 = true
		}
	}
	yyh1769.End()
	if yyc1769 {
		*v = yyv1769
	}
}

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

	yyv1775 := *v
	yyh1775, yyl1775 := z.DecSliceHelperStart()
	var yyc1775 bool
	if yyl1775 == 0 {
		if yyv1775 == nil {
			yyv1775 = []ClusterAutoscaler{}
			yyc1775 = true
		} else if len(yyv1775) != 0 {
			yyv1775 = yyv1775[:0]
			yyc1775 = true
		}
	} else if yyl1775 > 0 {
		var yyrr1775, yyrl1775 int
		var yyrt1775 bool
		if yyl1775 > cap(yyv1775) {

			yyrg1775 := len(yyv1775) > 0
			yyv21775 := yyv1775
			yyrl1775, yyrt1775 = z.DecInferLen(yyl1775, z.DecBasicHandle().MaxInitLen, 224)
			if yyrt1775 {
				if yyrl1775 <= cap(yyv1775) {
					yyv1775 = yyv1775[:yyrl1775]
				} else {
					yyv1775 = make([]ClusterAutoscaler, yyrl1775)
				}
			} else {
				yyv1775 = make([]ClusterAutoscaler, yyrl1775)
			}
			yyc1775 = true
			yyrr1775 = len(yyv1775)
			if yyrg1775 {
				copy(yyv1775, yyv21775)
			}
		} else if yyl1775 != len(yyv1775) {
			yyv1775 = yyv1775[:yyl1775]
			yyc1775 = true
		}
		yyj1775 := 0
		for ; yyj1775 < yyrr1775; yyj1775++ {
			yyh1775.ElemContainerState(yyj1775)
			if r.TryDecodeAsNil() {
				yyv1775[yyj1775] = ClusterAutoscaler{}
			} else {
				yyv1776 := &yyv1775[yyj1775]
				yyv1776.CodecDecodeSelf(d)
			}

		}
		if yyrt1775 {
			for ; yyj1775 < yyl1775; yyj1775++ {
				yyv1775 = append(yyv1775, ClusterAutoscaler{})
				yyh1775.ElemContainerState(yyj1775)
				if r.TryDecodeAsNil() {
					yyv1775[yyj1775] = ClusterAutoscaler{}
				} else {
					yyv1777 := &yyv1775[yyj1775]
					yyv1777.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1775 >= len(yyv1775) {
				yyv1775 = append(yyv1775, ClusterAutoscaler{}) // var yyz1775 ClusterAutoscaler
				yyc1775 = true
			}
			yyh1775.ElemContainerState(yyj1775)
			if yyj1775 < len(yyv1775) {
				if r.TryDecodeAsNil() {
					yyv1775[yyj1775] = ClusterAutoscaler{}
				} else {
					yyv1778 := &yyv1775[yyj1775]
					yyv1778.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1775 < len(yyv1775) {
			yyv1775 = yyv1775[:yyj1775]
			yyc1775 = true
		} else if yyj1775 == 0 && yyv1775 == nil {
			yyv1775 = []ClusterAutoscaler{}
			yyc1775 = true
		}
	}
	yyh1775.End()
	if yyc1775 {
		*v = yyv1775
	}
}

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

	yyv1781 := *v
	yyh1781, yyl1781 := z.DecSliceHelperStart()
	var yyc1781 bool
	if yyl1781 == 0 {
		if yyv1781 == nil {
			yyv1781 = []LabelSelectorRequirement{}
			yyc1781 = true
		} else if len(yyv1781) != 0 {
			yyv1781 = yyv1781[:0]
			yyc1781 = true
		}
	} else if yyl1781 > 0 {
		var yyrr1781, yyrl1781 int
		var yyrt1781 bool
		if yyl1781 > cap(yyv1781) {

			yyrg1781 := len(yyv1781) > 0
			yyv21781 := yyv1781
			yyrl1781, yyrt1781 = z.DecInferLen(yyl1781, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt1781 {
				if yyrl1781 <= cap(yyv1781) {
					yyv1781 = yyv1781[:yyrl1781]
				} else {
					yyv1781 = make([]LabelSelectorRequirement, yyrl1781)
				}
			} else {
				yyv1781 = make([]LabelSelectorRequirement, yyrl1781)
			}
			yyc1781 = true
			yyrr1781 = len(yyv1781)
			if yyrg1781 {
				copy(yyv1781, yyv21781)
			}
		} else if yyl1781 != len(yyv1781) {
			yyv1781 = yyv1781[:yyl1781]
			yyc1781 = true
		}
		yyj1781 := 0
		for ; yyj1781 < yyrr1781; yyj1781++ {
			yyh1781.ElemContainerState(yyj1781)
			if r.TryDecodeAsNil() {
				yyv1781[yyj1781] = LabelSelectorRequirement{}
			} else {
				yyv1782 := &yyv1781[yyj1781]
				yyv1782.CodecDecodeSelf(d)
			}

		}
		if yyrt1781 {
			for ; yyj1781 < yyl1781; yyj1781++ {
				yyv1781 = append(yyv1781, LabelSelectorRequirement{})
				yyh1781.ElemContainerState(yyj1781)
				if r.TryDecodeAsNil() {
					yyv1781[yyj1781] = LabelSelectorRequirement{}
				} else {
					yyv1783 := &yyv1781[yyj1781]
					yyv1783.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1781 >= len(yyv1781) {
				yyv1781 = append(yyv1781, LabelSelectorRequirement{}) // var yyz1781 LabelSelectorRequirement
				yyc1781 = true
			}
			yyh1781.ElemContainerState(yyj1781)
			if yyj1781 < len(yyv1781) {
				if r.TryDecodeAsNil() {
					yyv1781[yyj1781] = LabelSelectorRequirement{}
				} else {
					yyv1784 := &yyv1781[yyj1781]
					yyv1784.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1781 < len(yyv1781) {
			yyv1781 = yyv1781[:yyj1781]
			yyc1781 = true
		} else if yyj1781 == 0 && yyv1781 == nil {
			yyv1781 = []LabelSelectorRequirement{}
			yyc1781 = true
		}
	}
	yyh1781.End()
	if yyc1781 {
		*v = yyv1781
	}
}

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

	yyv1787 := *v
	yyh1787, yyl1787 := z.DecSliceHelperStart()
	var yyc1787 bool
	if yyl1787 == 0 {
		if yyv1787 == nil {
			yyv1787 = []ReplicaSet{}
			yyc1787 = true
		} else if len(yyv1787) != 0 {
			yyv1787 = yyv1787[:0]
			yyc1787 = true
		}
	} else if yyl1787 > 0 {
		var yyrr1787, yyrl1787 int
		var yyrt1787 bool
		if yyl1787 > cap(yyv1787) {

			yyrg1787 := len(yyv1787) > 0
			yyv21787 := yyv1787
			yyrl1787, yyrt1787 = z.DecInferLen(yyl1787, z.DecBasicHandle().MaxInitLen, 232)
			if yyrt1787 {
				if yyrl1787 <= cap(yyv1787) {
					yyv1787 = yyv1787[:yyrl1787]
				} else {
					yyv1787 = make([]ReplicaSet, yyrl1787)
				}
			} else {
				yyv1787 = make([]ReplicaSet, yyrl1787)
			}
			yyc1787 = true
			yyrr1787 = len(yyv1787)
			if yyrg1787 {
				copy(yyv1787, yyv21787)
			}
		} else if yyl1787 != len(yyv1787) {
			yyv1787 = yyv1787[:yyl1787]
			yyc1787 = true
		}
		yyj1787 := 0
		for ; yyj1787 < yyrr1787; yyj1787++ {
			yyh1787.ElemContainerState(yyj1787)
			if r.TryDecodeAsNil() {
				yyv1787[yyj1787] = ReplicaSet{}
			} else {
				yyv1788 := &yyv1787[yyj1787]
				yyv1788.CodecDecodeSelf(d)
			}

		}
		if yyrt1787 {
			for ; yyj1787 < yyl1787; yyj1787++ {
				yyv1787 = append(yyv1787, ReplicaSet{})
				yyh1787.ElemContainerState(yyj1787)
				if r.TryDecodeAsNil() {
					yyv1787[yyj1787] = ReplicaSet{}
				} else {
					yyv1789 := &yyv1787[yyj1787]
					yyv1789.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1787 >= len(yyv1787) {
				yyv1787 = append(yyv1787, ReplicaSet{}) // var yyz1787 ReplicaSet
				yyc1787 = true
			}
			yyh1787.ElemContainerState(yyj1787)
			if yyj1787 < len(yyv1787) {
				if r.TryDecodeAsNil() {
					yyv1787[yyj1787] = ReplicaSet{}
				} else {
					yyv1790 := &yyv1787[yyj1787]
					yyv1790.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1787 < len(yyv1787) {
			yyv1787 = yyv1787[:yyj1787]
			yyc1787 = true
		} else if yyj1787 == 0 && yyv1787 == nil {
			yyv1787 = []ReplicaSet{}
			yyc1787 = true
		}
	}
	yyh1787.End()
	if yyc1787 {
		*v = yyv1787
	}
}

func (x codecSelfer1234) encSlicev1_Capability(v []pkg2_v1.Capability, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1791 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yym1792 := z.EncBinary()
		_ = yym1792
		if false {
		} else if z.HasExtensions() && z.EncExt(yyv1791) {
		} else {
			r.EncodeString(codecSelferC_UTF81234, string(yyv1791))
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1793 := *v
	yyh1793, yyl1793 := z.DecSliceHelperStart()
	var yyc1793 bool
	if yyl1793 == 0 {
		if yyv1793 == nil {
			yyv1793 = []pkg2_v1.Capability{}
			yyc1793 = true
		} else if len(yyv1793) != 0 {
			yyv1793 = yyv1793[:0]
			yyc1793 = true
		}
	} else if yyl1793 > 0 {
		var yyrr1793, yyrl1793 int
		var yyrt1793 bool
		if yyl1793 > cap(yyv1793) {

			yyrl1793, yyrt1793 = z.DecInferLen(yyl1793, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1793 {
				if yyrl1793 <= cap(yyv1793) {
					yyv1793 = yyv1793[:yyrl1793]
				} else {
					yyv1793 = make([]pkg2_v1.Capability, yyrl1793)
				}
			} else {
				yyv1793 = make([]pkg2_v1.Capability, yyrl1793)
			}
			yyc1793 = true
			yyrr1793 = len(yyv1793)
		} else if yyl1793 != len(yyv1793) {
			yyv1793 = yyv1793[:yyl1793]
			yyc1793 = true
		}
		yyj1793 := 0
		for ; yyj1793 < yyrr1793; yyj1793++ {
			yyh1793.ElemContainerState(yyj1793)
			if r.TryDecodeAsNil() {
				yyv1793[yyj1793] = ""
			} else {
				yyv1793[yyj1793] = pkg2_v1.Capability(r.DecodeString())
			}

		}
		if yyrt1793 {
			for ; yyj1793 < yyl1793; yyj1793++ {
				yyv1793 = append(yyv1793, "")
				yyh1793.ElemContainerState(yyj1793)
				if r.TryDecodeAsNil() {
					yyv1793[yyj1793] = ""
				} else {
					yyv1793[yyj1793] = pkg2_v1.Capability(r.DecodeString())
				}

			}
		}

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

			if yyj1793 >= len(yyv1793) {
				yyv1793 = append(yyv1793, "") // var yyz1793 pkg2_v1.Capability
				yyc1793 = true
			}
			yyh1793.ElemContainerState(yyj1793)
			if yyj1793 < len(yyv1793) {
				if r.TryDecodeAsNil() {
					yyv1793[yyj1793] = ""
				} else {
					yyv1793[yyj1793] = pkg2_v1.Capability(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1793 < len(yyv1793) {
			yyv1793 = yyv1793[:yyj1793]
			yyc1793 = true
		} else if yyj1793 == 0 && yyv1793 == nil {
			yyv1793 = []pkg2_v1.Capability{}
			yyc1793 = true
		}
	}
	yyh1793.End()
	if yyc1793 {
		*v = yyv1793
	}
}

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

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

	yyv1798 := *v
	yyh1798, yyl1798 := z.DecSliceHelperStart()
	var yyc1798 bool
	if yyl1798 == 0 {
		if yyv1798 == nil {
			yyv1798 = []FSType{}
			yyc1798 = true
		} else if len(yyv1798) != 0 {
			yyv1798 = yyv1798[:0]
			yyc1798 = true
		}
	} else if yyl1798 > 0 {
		var yyrr1798, yyrl1798 int
		var yyrt1798 bool
		if yyl1798 > cap(yyv1798) {

			yyrl1798, yyrt1798 = z.DecInferLen(yyl1798, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1798 {
				if yyrl1798 <= cap(yyv1798) {
					yyv1798 = yyv1798[:yyrl1798]
				} else {
					yyv1798 = make([]FSType, yyrl1798)
				}
			} else {
				yyv1798 = make([]FSType, yyrl1798)
			}
			yyc1798 = true
			yyrr1798 = len(yyv1798)
		} else if yyl1798 != len(yyv1798) {
			yyv1798 = yyv1798[:yyl1798]
			yyc1798 = true
		}
		yyj1798 := 0
		for ; yyj1798 < yyrr1798; yyj1798++ {
			yyh1798.ElemContainerState(yyj1798)
			if r.TryDecodeAsNil() {
				yyv1798[yyj1798] = ""
			} else {
				yyv1798[yyj1798] = FSType(r.DecodeString())
			}

		}
		if yyrt1798 {
			for ; yyj1798 < yyl1798; yyj1798++ {
				yyv1798 = append(yyv1798, "")
				yyh1798.ElemContainerState(yyj1798)
				if r.TryDecodeAsNil() {
					yyv1798[yyj1798] = ""
				} else {
					yyv1798[yyj1798] = FSType(r.DecodeString())
				}

			}
		}

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

			if yyj1798 >= len(yyv1798) {
				yyv1798 = append(yyv1798, "") // var yyz1798 FSType
				yyc1798 = true
			}
			yyh1798.ElemContainerState(yyj1798)
			if yyj1798 < len(yyv1798) {
				if r.TryDecodeAsNil() {
					yyv1798[yyj1798] = ""
				} else {
					yyv1798[yyj1798] = FSType(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1798 < len(yyv1798) {
			yyv1798 = yyv1798[:yyj1798]
			yyc1798 = true
		} else if yyj1798 == 0 && yyv1798 == nil {
			yyv1798 = []FSType{}
			yyc1798 = true
		}
	}
	yyh1798.End()
	if yyc1798 {
		*v = yyv1798
	}
}

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

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

	yyv1804 := *v
	yyh1804, yyl1804 := z.DecSliceHelperStart()
	var yyc1804 bool
	if yyl1804 == 0 {
		if yyv1804 == nil {
			yyv1804 = []HostPortRange{}
			yyc1804 = true
		} else if len(yyv1804) != 0 {
			yyv1804 = yyv1804[:0]
			yyc1804 = true
		}
	} else if yyl1804 > 0 {
		var yyrr1804, yyrl1804 int
		var yyrt1804 bool
		if yyl1804 > cap(yyv1804) {

			yyrg1804 := len(yyv1804) > 0
			yyv21804 := yyv1804
			yyrl1804, yyrt1804 = z.DecInferLen(yyl1804, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1804 {
				if yyrl1804 <= cap(yyv1804) {
					yyv1804 = yyv1804[:yyrl1804]
				} else {
					yyv1804 = make([]HostPortRange, yyrl1804)
				}
			} else {
				yyv1804 = make([]HostPortRange, yyrl1804)
			}
			yyc1804 = true
			yyrr1804 = len(yyv1804)
			if yyrg1804 {
				copy(yyv1804, yyv21804)
			}
		} else if yyl1804 != len(yyv1804) {
			yyv1804 = yyv1804[:yyl1804]
			yyc1804 = true
		}
		yyj1804 := 0
		for ; yyj1804 < yyrr1804; yyj1804++ {
			yyh1804.ElemContainerState(yyj1804)
			if r.TryDecodeAsNil() {
				yyv1804[yyj1804] = HostPortRange{}
			} else {
				yyv1805 := &yyv1804[yyj1804]
				yyv1805.CodecDecodeSelf(d)
			}

		}
		if yyrt1804 {
			for ; yyj1804 < yyl1804; yyj1804++ {
				yyv1804 = append(yyv1804, HostPortRange{})
				yyh1804.ElemContainerState(yyj1804)
				if r.TryDecodeAsNil() {
					yyv1804[yyj1804] = HostPortRange{}
				} else {
					yyv1806 := &yyv1804[yyj1804]
					yyv1806.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1804 >= len(yyv1804) {
				yyv1804 = append(yyv1804, HostPortRange{}) // var yyz1804 HostPortRange
				yyc1804 = true
			}
			yyh1804.ElemContainerState(yyj1804)
			if yyj1804 < len(yyv1804) {
				if r.TryDecodeAsNil() {
					yyv1804[yyj1804] = HostPortRange{}
				} else {
					yyv1807 := &yyv1804[yyj1804]
					yyv1807.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1804 < len(yyv1804) {
			yyv1804 = yyv1804[:yyj1804]
			yyc1804 = true
		} else if yyj1804 == 0 && yyv1804 == nil {
			yyv1804 = []HostPortRange{}
			yyc1804 = true
		}
	}
	yyh1804.End()
	if yyc1804 {
		*v = yyv1804
	}
}

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

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

	yyv1810 := *v
	yyh1810, yyl1810 := z.DecSliceHelperStart()
	var yyc1810 bool
	if yyl1810 == 0 {
		if yyv1810 == nil {
			yyv1810 = []IDRange{}
			yyc1810 = true
		} else if len(yyv1810) != 0 {
			yyv1810 = yyv1810[:0]
			yyc1810 = true
		}
	} else if yyl1810 > 0 {
		var yyrr1810, yyrl1810 int
		var yyrt1810 bool
		if yyl1810 > cap(yyv1810) {

			yyrg1810 := len(yyv1810) > 0
			yyv21810 := yyv1810
			yyrl1810, yyrt1810 = z.DecInferLen(yyl1810, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1810 {
				if yyrl1810 <= cap(yyv1810) {
					yyv1810 = yyv1810[:yyrl1810]
				} else {
					yyv1810 = make([]IDRange, yyrl1810)
				}
			} else {
				yyv1810 = make([]IDRange, yyrl1810)
			}
			yyc1810 = true
			yyrr1810 = len(yyv1810)
			if yyrg1810 {
				copy(yyv1810, yyv21810)
			}
		} else if yyl1810 != len(yyv1810) {
			yyv1810 = yyv1810[:yyl1810]
			yyc1810 = true
		}
		yyj1810 := 0
		for ; yyj1810 < yyrr1810; yyj1810++ {
			yyh1810.ElemContainerState(yyj1810)
			if r.TryDecodeAsNil() {
				yyv1810[yyj1810] = IDRange{}
			} else {
				yyv1811 := &yyv1810[yyj1810]
				yyv1811.CodecDecodeSelf(d)
			}

		}
		if yyrt1810 {
			for ; yyj1810 < yyl1810; yyj1810++ {
				yyv1810 = append(yyv1810, IDRange{})
				yyh1810.ElemContainerState(yyj1810)
				if r.TryDecodeAsNil() {
					yyv1810[yyj1810] = IDRange{}
				} else {
					yyv1812 := &yyv1810[yyj1810]
					yyv1812.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1810 >= len(yyv1810) {
				yyv1810 = append(yyv1810, IDRange{}) // var yyz1810 IDRange
				yyc1810 = true
			}
			yyh1810.ElemContainerState(yyj1810)
			if yyj1810 < len(yyv1810) {
				if r.TryDecodeAsNil() {
					yyv1810[yyj1810] = IDRange{}
				} else {
					yyv1813 := &yyv1810[yyj1810]
					yyv1813.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1810 < len(yyv1810) {
			yyv1810 = yyv1810[:yyj1810]
			yyc1810 = true
		} else if yyj1810 == 0 && yyv1810 == nil {
			yyv1810 = []IDRange{}
			yyc1810 = true
		}
	}
	yyh1810.End()
	if yyc1810 {
		*v = yyv1810
	}
}

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

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

	yyv1816 := *v
	yyh1816, yyl1816 := z.DecSliceHelperStart()
	var yyc1816 bool
	if yyl1816 == 0 {
		if yyv1816 == nil {
			yyv1816 = []PodSecurityPolicy{}
			yyc1816 = true
		} else if len(yyv1816) != 0 {
			yyv1816 = yyv1816[:0]
			yyc1816 = true
		}
	} else if yyl1816 > 0 {
		var yyrr1816, yyrl1816 int
		var yyrt1816 bool
		if yyl1816 > cap(yyv1816) {

			yyrg1816 := len(yyv1816) > 0
			yyv21816 := yyv1816
			yyrl1816, yyrt1816 = z.DecInferLen(yyl1816, z.DecBasicHandle().MaxInitLen, 352)
			if yyrt1816 {
				if yyrl1816 <= cap(yyv1816) {
					yyv1816 = yyv1816[:yyrl1816]
				} else {
					yyv1816 = make([]PodSecurityPolicy, yyrl1816)
				}
			} else {
				yyv1816 = make([]PodSecurityPolicy, yyrl1816)
			}
			yyc1816 = true
			yyrr1816 = len(yyv1816)
			if yyrg1816 {
				copy(yyv1816, yyv21816)
			}
		} else if yyl1816 != len(yyv1816) {
			yyv1816 = yyv1816[:yyl1816]
			yyc1816 = true
		}
		yyj1816 := 0
		for ; yyj1816 < yyrr1816; yyj1816++ {
			yyh1816.ElemContainerState(yyj1816)
			if r.TryDecodeAsNil() {
				yyv1816[yyj1816] = PodSecurityPolicy{}
			} else {
				yyv1817 := &yyv1816[yyj1816]
				yyv1817.CodecDecodeSelf(d)
			}

		}
		if yyrt1816 {
			for ; yyj1816 < yyl1816; yyj1816++ {
				yyv1816 = append(yyv1816, PodSecurityPolicy{})
				yyh1816.ElemContainerState(yyj1816)
				if r.TryDecodeAsNil() {
					yyv1816[yyj1816] = PodSecurityPolicy{}
				} else {
					yyv1818 := &yyv1816[yyj1816]
					yyv1818.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1816 >= len(yyv1816) {
				yyv1816 = append(yyv1816, PodSecurityPolicy{}) // var yyz1816 PodSecurityPolicy
				yyc1816 = true
			}
			yyh1816.ElemContainerState(yyj1816)
			if yyj1816 < len(yyv1816) {
				if r.TryDecodeAsNil() {
					yyv1816[yyj1816] = PodSecurityPolicy{}
				} else {
					yyv1819 := &yyv1816[yyj1816]
					yyv1819.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1816 < len(yyv1816) {
			yyv1816 = yyv1816[:yyj1816]
			yyc1816 = true
		} else if yyj1816 == 0 && yyv1816 == nil {
			yyv1816 = []PodSecurityPolicy{}
			yyc1816 = true
		}
	}
	yyh1816.End()
	if yyc1816 {
		*v = yyv1816
	}
}