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 extensions

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

const (
	codecSelferC_UTF81234         = 1
	codecSelferC_RAW1234          = 0
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
)

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 != 4 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			4, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg2_api.ObjectMeta
		var v1 pkg4_resource.Quantity
		var v2 pkg1_unversioned.TypeMeta
		var v3 pkg3_types.UID
		var v4 pkg6_util.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
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				var yynn2 int = 0
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
			}
			if yyr2 || yy2arr2 {
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq2[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yysep2 {
				r.EncodeEnd()
			}
		}
	}
}

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 {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl7 := r.ReadMapStart()
			if yyl7 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl7, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl7 := r.ReadArrayStart()
			if yyl7 == 0 {
				r.ReadEnd()
			} 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
			}
		}
		yys8Slc = r.DecodeBytes(yys8Slc, true, true)
		yys8 := string(yys8Slc)
		switch yys8 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys8)
		} // end switch yys8
	} // end for yyj8
	if !yyhl8 {
		r.ReadEnd()
	}
}

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 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	r.ReadEnd()
}

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
			if yyr13 || yy2arr13 {
				r.EncodeArrayStart(2)
			} else {
				var yynn13 int = 1
				for _, b := range yyq13 {
					if b {
						yynn13++
					}
				}
				r.EncodeMapStart(yynn13)
			}
			if yyr13 || yy2arr13 {
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr13 || yy2arr13 {
				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] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym19 := z.EncBinary()
						_ = yym19
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yysep13 {
				r.EncodeEnd()
			}
		}
	}
}

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 {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl21 := r.ReadMapStart()
			if yyl21 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl21, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl21 := r.ReadArrayStart()
			if yyl21 == 0 {
				r.ReadEnd()
			} 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
			}
		}
		yys22Slc = r.DecodeBytes(yys22Slc, true, true)
		yys22 := string(yys22Slc)
		switch yys22 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv24 := &x.Selector
				yym25 := z.DecBinary()
				_ = yym25
				if false {
				} else {
					z.F.DecMapStringStringX(yyv24, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys22)
		} // end switch yys22
	} // end for yyj22
	if !yyhl22 {
		r.ReadEnd()
	}
}

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 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadEnd()
		return
	}
	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.DecStructFieldNotFound(yyj26-1, "")
	}
	r.ReadEnd()
}

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

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 {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl48 := r.ReadMapStart()
			if yyl48 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl48, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl48 := r.ReadArrayStart()
			if yyl48 == 0 {
				r.ReadEnd()
			} 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
			}
		}
		yys49Slc = r.DecodeBytes(yys49Slc, true, true)
		yys49 := string(yys49Slc)
		switch yys49 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	if !yyhl49 {
		r.ReadEnd()
	}
}

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 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv58 := &x.ObjectMeta
		yyv58.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv59 := &x.Spec
		yyv59.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv60 := &x.Status
		yyv60.CodecDecodeSelf(d)
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecStructFieldNotFound(yyj55-1, "")
	}
	r.ReadEnd()
}

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 != ""
			if yyr62 || yy2arr62 {
				r.EncodeArrayStart(2)
			} else {
				var yynn62 int = 0
				for _, b := range yyq62 {
					if b {
						yynn62++
					}
				}
				r.EncodeMapStart(yynn62)
			}
			if yyr62 || yy2arr62 {
				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] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym65 := z.EncBinary()
					_ = yym65
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr62 || yy2arr62 {
				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] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym68 := z.EncBinary()
					_ = yym68
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yysep62 {
				r.EncodeEnd()
			}
		}
	}
}

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 {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl70 := r.ReadMapStart()
			if yyl70 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl70, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl70 := r.ReadArrayStart()
			if yyl70 == 0 {
				r.ReadEnd()
			} 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
			}
		}
		yys71Slc = r.DecodeBytes(yys71Slc, true, true)
		yys71 := string(yys71Slc)
		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
	if !yyhl71 {
		r.ReadEnd()
	}
}

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 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		r.ReadEnd()
		return
	}
	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.DecStructFieldNotFound(yyj74-1, "")
	}
	r.ReadEnd()
}

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 [5]bool
			_, _, _ = yysep78, yyq78, yy2arr78
			const yyr78 bool = false
			yyq78[0] = x.Kind != ""
			yyq78[1] = x.Namespace != ""
			yyq78[2] = x.Name != ""
			yyq78[3] = x.APIVersion != ""
			yyq78[4] = x.Subresource != ""
			if yyr78 || yy2arr78 {
				r.EncodeArrayStart(5)
			} else {
				var yynn78 int = 0
				for _, b := range yyq78 {
					if b {
						yynn78++
					}
				}
				r.EncodeMapStart(yynn78)
			}
			if yyr78 || yy2arr78 {
				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] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym81 := z.EncBinary()
					_ = yym81
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[1] {
					yym83 := z.EncBinary()
					_ = yym83
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[1] {
					r.EncodeString(codecSelferC_UTF81234, string("namespace"))
					yym84 := z.EncBinary()
					_ = yym84
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[2] {
					yym86 := z.EncBinary()
					_ = yym86
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[2] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					yym87 := z.EncBinary()
					_ = yym87
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[3] {
					yym89 := z.EncBinary()
					_ = yym89
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[3] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym90 := z.EncBinary()
					_ = yym90
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[4] {
					yym92 := z.EncBinary()
					_ = yym92
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[4] {
					r.EncodeString(codecSelferC_UTF81234, string("subresource"))
					yym93 := z.EncBinary()
					_ = yym93
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				}
			}
			if yysep78 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *SubresourceReference) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym94 := z.DecBinary()
	_ = yym94
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl95 := r.ReadMapStart()
			if yyl95 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl95, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl95 := r.ReadArrayStart()
			if yyl95 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl95, 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 yys96Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys96Slc
	var yyhl96 bool = l >= 0
	for yyj96 := 0; ; yyj96++ {
		if yyhl96 {
			if yyj96 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys96Slc = r.DecodeBytes(yys96Slc, true, true)
		yys96 := string(yys96Slc)
		switch yys96 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				x.Namespace = 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, yys96)
		} // end switch yys96
	} // end for yyj96
	if !yyhl96 {
		r.ReadEnd()
	}
}

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

func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym108 := z.EncBinary()
		_ = yym108
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep109 := !z.EncBinary()
			yy2arr109 := z.EncBasicHandle().StructToArray
			var yyq109 [1]bool
			_, _, _ = yysep109, yyq109, yy2arr109
			const yyr109 bool = false
			if yyr109 || yy2arr109 {
				r.EncodeArrayStart(1)
			} else {
				var yynn109 int = 1
				for _, b := range yyq109 {
					if b {
						yynn109++
					}
				}
				r.EncodeMapStart(yynn109)
			}
			if yyr109 || yy2arr109 {
				yym111 := z.EncBinary()
				_ = yym111
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("targetPercentage"))
				yym112 := z.EncBinary()
				_ = yym112
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			}
			if yysep109 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *CPUTargetUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym113 := z.DecBinary()
	_ = yym113
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl114 := r.ReadMapStart()
			if yyl114 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl114, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl114 := r.ReadArrayStart()
			if yyl114 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl114, 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 yys115Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys115Slc
	var yyhl115 bool = l >= 0
	for yyj115 := 0; ; yyj115++ {
		if yyhl115 {
			if yyj115 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys115Slc = r.DecodeBytes(yys115Slc, true, true)
		yys115 := string(yys115Slc)
		switch yys115 {
		case "targetPercentage":
			if r.TryDecodeAsNil() {
				x.TargetPercentage = 0
			} else {
				x.TargetPercentage = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys115)
		} // end switch yys115
	} // end for yyj115
	if !yyhl115 {
		r.ReadEnd()
	}
}

func (x *CPUTargetUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj117 int
	var yyb117 bool
	var yyhl117 bool = l >= 0
	yyj117++
	if yyhl117 {
		yyb117 = yyj117 > l
	} else {
		yyb117 = r.CheckBreak()
	}
	if yyb117 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetPercentage = 0
	} else {
		x.TargetPercentage = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj117++
		if yyhl117 {
			yyb117 = yyj117 > l
		} else {
			yyb117 = r.CheckBreak()
		}
		if yyb117 {
			break
		}
		z.DecStructFieldNotFound(yyj117-1, "")
	}
	r.ReadEnd()
}

func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym119 := z.EncBinary()
		_ = yym119
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep120 := !z.EncBinary()
			yy2arr120 := z.EncBasicHandle().StructToArray
			var yyq120 [4]bool
			_, _, _ = yysep120, yyq120, yy2arr120
			const yyr120 bool = false
			yyq120[1] = x.MinReplicas != nil
			yyq120[3] = x.CPUUtilization != nil
			if yyr120 || yy2arr120 {
				r.EncodeArrayStart(4)
			} else {
				var yynn120 int = 2
				for _, b := range yyq120 {
					if b {
						yynn120++
					}
				}
				r.EncodeMapStart(yynn120)
			}
			if yyr120 || yy2arr120 {
				yy122 := &x.ScaleRef
				yy122.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
				yy123 := &x.ScaleRef
				yy123.CodecEncodeSelf(e)
			}
			if yyr120 || yy2arr120 {
				if yyq120[1] {
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy125 := *x.MinReplicas
						yym126 := z.EncBinary()
						_ = yym126
						if false {
						} else {
							r.EncodeInt(int64(yy125))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq120[1] {
					r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy127 := *x.MinReplicas
						yym128 := z.EncBinary()
						_ = yym128
						if false {
						} else {
							r.EncodeInt(int64(yy127))
						}
					}
				}
			}
			if yyr120 || yy2arr120 {
				yym130 := z.EncBinary()
				_ = yym130
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
				yym131 := z.EncBinary()
				_ = yym131
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			}
			if yyr120 || yy2arr120 {
				if yyq120[3] {
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq120[3] {
					r.EncodeString(codecSelferC_UTF81234, string("cpuUtilization"))
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				}
			}
			if yysep120 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym133 := z.DecBinary()
	_ = yym133
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl134 := r.ReadMapStart()
			if yyl134 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl134, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl134 := r.ReadArrayStart()
			if yyl134 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl134, 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 yys135Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys135Slc
	var yyhl135 bool = l >= 0
	for yyj135 := 0; ; yyj135++ {
		if yyhl135 {
			if yyj135 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys135Slc = r.DecodeBytes(yys135Slc, true, true)
		yys135 := string(yys135Slc)
		switch yys135 {
		case "scaleRef":
			if r.TryDecodeAsNil() {
				x.ScaleRef = SubresourceReference{}
			} else {
				yyv136 := &x.ScaleRef
				yyv136.CodecDecodeSelf(d)
			}
		case "minReplicas":
			if r.TryDecodeAsNil() {
				if x.MinReplicas != nil {
					x.MinReplicas = nil
				}
			} else {
				if x.MinReplicas == nil {
					x.MinReplicas = new(int)
				}
				yym138 := z.DecBinary()
				_ = yym138
				if false {
				} else {
					*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "cpuUtilization":
			if r.TryDecodeAsNil() {
				if x.CPUUtilization != nil {
					x.CPUUtilization = nil
				}
			} else {
				if x.CPUUtilization == nil {
					x.CPUUtilization = new(CPUTargetUtilization)
				}
				x.CPUUtilization.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys135)
		} // end switch yys135
	} // end for yyj135
	if !yyhl135 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj141 int
	var yyb141 bool
	var yyhl141 bool = l >= 0
	yyj141++
	if yyhl141 {
		yyb141 = yyj141 > l
	} else {
		yyb141 = r.CheckBreak()
	}
	if yyb141 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ScaleRef = SubresourceReference{}
	} else {
		yyv142 := &x.ScaleRef
		yyv142.CodecDecodeSelf(d)
	}
	yyj141++
	if yyhl141 {
		yyb141 = yyj141 > l
	} else {
		yyb141 = r.CheckBreak()
	}
	if yyb141 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MinReplicas != nil {
			x.MinReplicas = nil
		}
	} else {
		if x.MinReplicas == nil {
			x.MinReplicas = new(int)
		}
		yym144 := z.DecBinary()
		_ = yym144
		if false {
		} else {
			*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj141++
	if yyhl141 {
		yyb141 = yyj141 > l
	} else {
		yyb141 = r.CheckBreak()
	}
	if yyb141 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxReplicas = 0
	} else {
		x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj141++
	if yyhl141 {
		yyb141 = yyj141 > l
	} else {
		yyb141 = r.CheckBreak()
	}
	if yyb141 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.CPUUtilization != nil {
			x.CPUUtilization = nil
		}
	} else {
		if x.CPUUtilization == nil {
			x.CPUUtilization = new(CPUTargetUtilization)
		}
		x.CPUUtilization.CodecDecodeSelf(d)
	}
	for {
		yyj141++
		if yyhl141 {
			yyb141 = yyj141 > l
		} else {
			yyb141 = r.CheckBreak()
		}
		if yyb141 {
			break
		}
		z.DecStructFieldNotFound(yyj141-1, "")
	}
	r.ReadEnd()
}

func (x *HorizontalPodAutoscalerStatus) 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 [5]bool
			_, _, _ = yysep148, yyq148, yy2arr148
			const yyr148 bool = false
			yyq148[0] = x.ObservedGeneration != nil
			yyq148[1] = x.LastScaleTime != nil
			yyq148[4] = x.CurrentCPUUtilizationPercentage != nil
			if yyr148 || yy2arr148 {
				r.EncodeArrayStart(5)
			} else {
				var yynn148 int = 2
				for _, b := range yyq148 {
					if b {
						yynn148++
					}
				}
				r.EncodeMapStart(yynn148)
			}
			if yyr148 || yy2arr148 {
				if yyq148[0] {
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy150 := *x.ObservedGeneration
						yym151 := z.EncBinary()
						_ = yym151
						if false {
						} else {
							r.EncodeInt(int64(yy150))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq148[0] {
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy152 := *x.ObservedGeneration
						yym153 := z.EncBinary()
						_ = yym153
						if false {
						} else {
							r.EncodeInt(int64(yy152))
						}
					}
				}
			}
			if yyr148 || yy2arr148 {
				if yyq148[1] {
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym155 := z.EncBinary()
						_ = yym155
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym155 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym155 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq148[1] {
					r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym156 := z.EncBinary()
						_ = yym156
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym156 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym156 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				}
			}
			if yyr148 || yy2arr148 {
				yym158 := z.EncBinary()
				_ = yym158
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
				yym159 := z.EncBinary()
				_ = yym159
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			}
			if yyr148 || yy2arr148 {
				yym161 := z.EncBinary()
				_ = yym161
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
				yym162 := z.EncBinary()
				_ = yym162
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			}
			if yyr148 || yy2arr148 {
				if yyq148[4] {
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy164 := *x.CurrentCPUUtilizationPercentage
						yym165 := z.EncBinary()
						_ = yym165
						if false {
						} else {
							r.EncodeInt(int64(yy164))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq148[4] {
					r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy166 := *x.CurrentCPUUtilizationPercentage
						yym167 := z.EncBinary()
						_ = yym167
						if false {
						} else {
							r.EncodeInt(int64(yy166))
						}
					}
				}
			}
			if yysep148 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym168 := z.DecBinary()
	_ = yym168
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl169 := r.ReadMapStart()
			if yyl169 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl169, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl169 := r.ReadArrayStart()
			if yyl169 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl169, 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 yys170Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys170Slc
	var yyhl170 bool = l >= 0
	for yyj170 := 0; ; yyj170++ {
		if yyhl170 {
			if yyj170 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys170Slc = r.DecodeBytes(yys170Slc, true, true)
		yys170 := string(yys170Slc)
		switch yys170 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				if x.ObservedGeneration != nil {
					x.ObservedGeneration = nil
				}
			} else {
				if x.ObservedGeneration == nil {
					x.ObservedGeneration = new(int64)
				}
				yym172 := z.DecBinary()
				_ = yym172
				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)
				}
				yym174 := z.DecBinary()
				_ = yym174
				if false {
				} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
				} else if yym174 {
					z.DecBinaryUnmarshal(x.LastScaleTime)
				} else if !yym174 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.LastScaleTime)
				} else {
					z.DecFallback(x.LastScaleTime, false)
				}
			}
		case "currentReplicas":
			if r.TryDecodeAsNil() {
				x.CurrentReplicas = 0
			} else {
				x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int)
				}
				yym178 := z.DecBinary()
				_ = yym178
				if false {
				} else {
					*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys170)
		} // end switch yys170
	} // end for yyj170
	if !yyhl170 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj179 int
	var yyb179 bool
	var yyhl179 bool = l >= 0
	yyj179++
	if yyhl179 {
		yyb179 = yyj179 > l
	} else {
		yyb179 = r.CheckBreak()
	}
	if yyb179 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.ObservedGeneration != nil {
			x.ObservedGeneration = nil
		}
	} else {
		if x.ObservedGeneration == nil {
			x.ObservedGeneration = new(int64)
		}
		yym181 := z.DecBinary()
		_ = yym181
		if false {
		} else {
			*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
		}
	}
	yyj179++
	if yyhl179 {
		yyb179 = yyj179 > l
	} else {
		yyb179 = r.CheckBreak()
	}
	if yyb179 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.LastScaleTime != nil {
			x.LastScaleTime = nil
		}
	} else {
		if x.LastScaleTime == nil {
			x.LastScaleTime = new(pkg1_unversioned.Time)
		}
		yym183 := z.DecBinary()
		_ = yym183
		if false {
		} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
		} else if yym183 {
			z.DecBinaryUnmarshal(x.LastScaleTime)
		} else if !yym183 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.LastScaleTime)
		} else {
			z.DecFallback(x.LastScaleTime, false)
		}
	}
	yyj179++
	if yyhl179 {
		yyb179 = yyj179 > l
	} else {
		yyb179 = r.CheckBreak()
	}
	if yyb179 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentReplicas = 0
	} else {
		x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj179++
	if yyhl179 {
		yyb179 = yyj179 > l
	} else {
		yyb179 = r.CheckBreak()
	}
	if yyb179 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredReplicas = 0
	} else {
		x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj179++
	if yyhl179 {
		yyb179 = yyj179 > l
	} else {
		yyb179 = r.CheckBreak()
	}
	if yyb179 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.CurrentCPUUtilizationPercentage != nil {
			x.CurrentCPUUtilizationPercentage = nil
		}
	} else {
		if x.CurrentCPUUtilizationPercentage == nil {
			x.CurrentCPUUtilizationPercentage = new(int)
		}
		yym187 := z.DecBinary()
		_ = yym187
		if false {
		} else {
			*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	for {
		yyj179++
		if yyhl179 {
			yyb179 = yyj179 > l
		} else {
			yyb179 = r.CheckBreak()
		}
		if yyb179 {
			break
		}
		z.DecStructFieldNotFound(yyj179-1, "")
	}
	r.ReadEnd()
}

func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym188 := z.EncBinary()
		_ = yym188
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep189 := !z.EncBinary()
			yy2arr189 := z.EncBasicHandle().StructToArray
			var yyq189 [5]bool
			_, _, _ = yysep189, yyq189, yy2arr189
			const yyr189 bool = false
			yyq189[0] = x.Kind != ""
			yyq189[1] = x.APIVersion != ""
			yyq189[2] = true
			yyq189[3] = true
			yyq189[4] = true
			if yyr189 || yy2arr189 {
				r.EncodeArrayStart(5)
			} else {
				var yynn189 int = 0
				for _, b := range yyq189 {
					if b {
						yynn189++
					}
				}
				r.EncodeMapStart(yynn189)
			}
			if yyr189 || yy2arr189 {
				if yyq189[0] {
					yym191 := z.EncBinary()
					_ = yym191
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq189[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym192 := z.EncBinary()
					_ = yym192
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr189 || yy2arr189 {
				if yyq189[1] {
					yym194 := z.EncBinary()
					_ = yym194
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq189[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym195 := z.EncBinary()
					_ = yym195
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr189 || yy2arr189 {
				if yyq189[2] {
					yy197 := &x.ObjectMeta
					yy197.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq189[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy198 := &x.ObjectMeta
					yy198.CodecEncodeSelf(e)
				}
			}
			if yyr189 || yy2arr189 {
				if yyq189[3] {
					yy200 := &x.Spec
					yy200.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq189[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy201 := &x.Spec
					yy201.CodecEncodeSelf(e)
				}
			}
			if yyr189 || yy2arr189 {
				if yyq189[4] {
					yy203 := &x.Status
					yy203.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq189[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy204 := &x.Status
					yy204.CodecEncodeSelf(e)
				}
			}
			if yysep189 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym205 := z.DecBinary()
	_ = yym205
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl206 := r.ReadMapStart()
			if yyl206 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl206, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl206 := r.ReadArrayStart()
			if yyl206 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl206, 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 yys207Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys207Slc
	var yyhl207 bool = l >= 0
	for yyj207 := 0; ; yyj207++ {
		if yyhl207 {
			if yyj207 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys207Slc = r.DecodeBytes(yys207Slc, true, true)
		yys207 := string(yys207Slc)
		switch yys207 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv210 := &x.ObjectMeta
				yyv210.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = HorizontalPodAutoscalerSpec{}
			} else {
				yyv211 := &x.Spec
				yyv211.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = HorizontalPodAutoscalerStatus{}
			} else {
				yyv212 := &x.Status
				yyv212.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys207)
		} // end switch yys207
	} // end for yyj207
	if !yyhl207 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj213 int
	var yyb213 bool
	var yyhl213 bool = l >= 0
	yyj213++
	if yyhl213 {
		yyb213 = yyj213 > l
	} else {
		yyb213 = r.CheckBreak()
	}
	if yyb213 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj213++
	if yyhl213 {
		yyb213 = yyj213 > l
	} else {
		yyb213 = r.CheckBreak()
	}
	if yyb213 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj213++
	if yyhl213 {
		yyb213 = yyj213 > l
	} else {
		yyb213 = r.CheckBreak()
	}
	if yyb213 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv216 := &x.ObjectMeta
		yyv216.CodecDecodeSelf(d)
	}
	yyj213++
	if yyhl213 {
		yyb213 = yyj213 > l
	} else {
		yyb213 = r.CheckBreak()
	}
	if yyb213 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = HorizontalPodAutoscalerSpec{}
	} else {
		yyv217 := &x.Spec
		yyv217.CodecDecodeSelf(d)
	}
	yyj213++
	if yyhl213 {
		yyb213 = yyj213 > l
	} else {
		yyb213 = r.CheckBreak()
	}
	if yyb213 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = HorizontalPodAutoscalerStatus{}
	} else {
		yyv218 := &x.Status
		yyv218.CodecDecodeSelf(d)
	}
	for {
		yyj213++
		if yyhl213 {
			yyb213 = yyj213 > l
		} else {
			yyb213 = r.CheckBreak()
		}
		if yyb213 {
			break
		}
		z.DecStructFieldNotFound(yyj213-1, "")
	}
	r.ReadEnd()
}

func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym219 := z.EncBinary()
		_ = yym219
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep220 := !z.EncBinary()
			yy2arr220 := z.EncBasicHandle().StructToArray
			var yyq220 [4]bool
			_, _, _ = yysep220, yyq220, yy2arr220
			const yyr220 bool = false
			yyq220[0] = x.Kind != ""
			yyq220[1] = x.APIVersion != ""
			yyq220[2] = true
			if yyr220 || yy2arr220 {
				r.EncodeArrayStart(4)
			} else {
				var yynn220 int = 1
				for _, b := range yyq220 {
					if b {
						yynn220++
					}
				}
				r.EncodeMapStart(yynn220)
			}
			if yyr220 || yy2arr220 {
				if yyq220[0] {
					yym222 := z.EncBinary()
					_ = yym222
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym223 := z.EncBinary()
					_ = yym223
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr220 || yy2arr220 {
				if yyq220[1] {
					yym225 := z.EncBinary()
					_ = yym225
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym226 := z.EncBinary()
					_ = yym226
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr220 || yy2arr220 {
				if yyq220[2] {
					yy228 := &x.ListMeta
					yym229 := z.EncBinary()
					_ = yym229
					if false {
					} else if z.HasExtensions() && z.EncExt(yy228) {
					} else {
						z.EncFallback(yy228)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq220[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy230 := &x.ListMeta
					yym231 := z.EncBinary()
					_ = yym231
					if false {
					} else if z.HasExtensions() && z.EncExt(yy230) {
					} else {
						z.EncFallback(yy230)
					}
				}
			}
			if yyr220 || yy2arr220 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym233 := z.EncBinary()
					_ = yym233
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym234 := z.EncBinary()
					_ = yym234
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep220 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym235 := z.DecBinary()
	_ = yym235
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl236 := r.ReadMapStart()
			if yyl236 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl236, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl236 := r.ReadArrayStart()
			if yyl236 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl236, 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 yys237Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys237Slc
	var yyhl237 bool = l >= 0
	for yyj237 := 0; ; yyj237++ {
		if yyhl237 {
			if yyj237 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys237Slc = r.DecodeBytes(yys237Slc, true, true)
		yys237 := string(yys237Slc)
		switch yys237 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv240 := &x.ListMeta
				yym241 := z.DecBinary()
				_ = yym241
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv240) {
				} else {
					z.DecFallback(yyv240, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv242 := &x.Items
				yym243 := z.DecBinary()
				_ = yym243
				if false {
				} else {
					h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv242), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys237)
		} // end switch yys237
	} // end for yyj237
	if !yyhl237 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj244 int
	var yyb244 bool
	var yyhl244 bool = l >= 0
	yyj244++
	if yyhl244 {
		yyb244 = yyj244 > l
	} else {
		yyb244 = r.CheckBreak()
	}
	if yyb244 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj244++
	if yyhl244 {
		yyb244 = yyj244 > l
	} else {
		yyb244 = r.CheckBreak()
	}
	if yyb244 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj244++
	if yyhl244 {
		yyb244 = yyj244 > l
	} else {
		yyb244 = r.CheckBreak()
	}
	if yyb244 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv247 := &x.ListMeta
		yym248 := z.DecBinary()
		_ = yym248
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv247) {
		} else {
			z.DecFallback(yyv247, false)
		}
	}
	yyj244++
	if yyhl244 {
		yyb244 = yyj244 > l
	} else {
		yyb244 = r.CheckBreak()
	}
	if yyb244 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv249 := &x.Items
		yym250 := z.DecBinary()
		_ = yym250
		if false {
		} else {
			h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv249), d)
		}
	}
	for {
		yyj244++
		if yyhl244 {
			yyb244 = yyj244 > l
		} else {
			yyb244 = r.CheckBreak()
		}
		if yyb244 {
			break
		}
		z.DecStructFieldNotFound(yyj244-1, "")
	}
	r.ReadEnd()
}

func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym251 := z.EncBinary()
		_ = yym251
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep252 := !z.EncBinary()
			yy2arr252 := z.EncBasicHandle().StructToArray
			var yyq252 [5]bool
			_, _, _ = yysep252, yyq252, yy2arr252
			const yyr252 bool = false
			yyq252[0] = x.Kind != ""
			yyq252[1] = x.APIVersion != ""
			yyq252[2] = true
			yyq252[3] = x.Description != ""
			yyq252[4] = len(x.Versions) != 0
			if yyr252 || yy2arr252 {
				r.EncodeArrayStart(5)
			} else {
				var yynn252 int = 0
				for _, b := range yyq252 {
					if b {
						yynn252++
					}
				}
				r.EncodeMapStart(yynn252)
			}
			if yyr252 || yy2arr252 {
				if yyq252[0] {
					yym254 := z.EncBinary()
					_ = yym254
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq252[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym255 := z.EncBinary()
					_ = yym255
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr252 || yy2arr252 {
				if yyq252[1] {
					yym257 := z.EncBinary()
					_ = yym257
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq252[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym258 := z.EncBinary()
					_ = yym258
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr252 || yy2arr252 {
				if yyq252[2] {
					yy260 := &x.ObjectMeta
					yy260.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq252[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy261 := &x.ObjectMeta
					yy261.CodecEncodeSelf(e)
				}
			}
			if yyr252 || yy2arr252 {
				if yyq252[3] {
					yym263 := z.EncBinary()
					_ = yym263
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq252[3] {
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					yym264 := z.EncBinary()
					_ = yym264
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr252 || yy2arr252 {
				if yyq252[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym266 := z.EncBinary()
						_ = yym266
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq252[4] {
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym267 := z.EncBinary()
						_ = yym267
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yysep252 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym268 := z.DecBinary()
	_ = yym268
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl269 := r.ReadMapStart()
			if yyl269 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl269, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl269 := r.ReadArrayStart()
			if yyl269 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl269, 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 yys270Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys270Slc
	var yyhl270 bool = l >= 0
	for yyj270 := 0; ; yyj270++ {
		if yyhl270 {
			if yyj270 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys270Slc = r.DecodeBytes(yys270Slc, true, true)
		yys270 := string(yys270Slc)
		switch yys270 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv273 := &x.ObjectMeta
				yyv273.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv275 := &x.Versions
				yym276 := z.DecBinary()
				_ = yym276
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv275), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys270)
		} // end switch yys270
	} // end for yyj270
	if !yyhl270 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj277 int
	var yyb277 bool
	var yyhl277 bool = l >= 0
	yyj277++
	if yyhl277 {
		yyb277 = yyj277 > l
	} else {
		yyb277 = r.CheckBreak()
	}
	if yyb277 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj277++
	if yyhl277 {
		yyb277 = yyj277 > l
	} else {
		yyb277 = r.CheckBreak()
	}
	if yyb277 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj277++
	if yyhl277 {
		yyb277 = yyj277 > l
	} else {
		yyb277 = r.CheckBreak()
	}
	if yyb277 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv280 := &x.ObjectMeta
		yyv280.CodecDecodeSelf(d)
	}
	yyj277++
	if yyhl277 {
		yyb277 = yyj277 > l
	} else {
		yyb277 = r.CheckBreak()
	}
	if yyb277 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj277++
	if yyhl277 {
		yyb277 = yyj277 > l
	} else {
		yyb277 = r.CheckBreak()
	}
	if yyb277 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv282 := &x.Versions
		yym283 := z.DecBinary()
		_ = yym283
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv282), d)
		}
	}
	for {
		yyj277++
		if yyhl277 {
			yyb277 = yyj277 > l
		} else {
			yyb277 = r.CheckBreak()
		}
		if yyb277 {
			break
		}
		z.DecStructFieldNotFound(yyj277-1, "")
	}
	r.ReadEnd()
}

func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym284 := z.EncBinary()
		_ = yym284
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep285 := !z.EncBinary()
			yy2arr285 := z.EncBasicHandle().StructToArray
			var yyq285 [4]bool
			_, _, _ = yysep285, yyq285, yy2arr285
			const yyr285 bool = false
			yyq285[0] = x.Kind != ""
			yyq285[1] = x.APIVersion != ""
			yyq285[2] = true
			if yyr285 || yy2arr285 {
				r.EncodeArrayStart(4)
			} else {
				var yynn285 int = 1
				for _, b := range yyq285 {
					if b {
						yynn285++
					}
				}
				r.EncodeMapStart(yynn285)
			}
			if yyr285 || yy2arr285 {
				if yyq285[0] {
					yym287 := z.EncBinary()
					_ = yym287
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq285[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym288 := z.EncBinary()
					_ = yym288
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr285 || yy2arr285 {
				if yyq285[1] {
					yym290 := z.EncBinary()
					_ = yym290
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq285[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym291 := z.EncBinary()
					_ = yym291
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr285 || yy2arr285 {
				if yyq285[2] {
					yy293 := &x.ListMeta
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else if z.HasExtensions() && z.EncExt(yy293) {
					} else {
						z.EncFallback(yy293)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq285[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy295 := &x.ListMeta
					yym296 := z.EncBinary()
					_ = yym296
					if false {
					} else if z.HasExtensions() && z.EncExt(yy295) {
					} else {
						z.EncFallback(yy295)
					}
				}
			}
			if yyr285 || yy2arr285 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym298 := z.EncBinary()
					_ = yym298
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym299 := z.EncBinary()
					_ = yym299
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yysep285 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym300 := z.DecBinary()
	_ = yym300
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl301 := r.ReadMapStart()
			if yyl301 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl301, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl301 := r.ReadArrayStart()
			if yyl301 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl301, 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 yys302Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys302Slc
	var yyhl302 bool = l >= 0
	for yyj302 := 0; ; yyj302++ {
		if yyhl302 {
			if yyj302 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys302Slc = r.DecodeBytes(yys302Slc, true, true)
		yys302 := string(yys302Slc)
		switch yys302 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv305 := &x.ListMeta
				yym306 := z.DecBinary()
				_ = yym306
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv305) {
				} else {
					z.DecFallback(yyv305, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv307 := &x.Items
				yym308 := z.DecBinary()
				_ = yym308
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv307), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys302)
		} // end switch yys302
	} // end for yyj302
	if !yyhl302 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj309 int
	var yyb309 bool
	var yyhl309 bool = l >= 0
	yyj309++
	if yyhl309 {
		yyb309 = yyj309 > l
	} else {
		yyb309 = r.CheckBreak()
	}
	if yyb309 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj309++
	if yyhl309 {
		yyb309 = yyj309 > l
	} else {
		yyb309 = r.CheckBreak()
	}
	if yyb309 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj309++
	if yyhl309 {
		yyb309 = yyj309 > l
	} else {
		yyb309 = r.CheckBreak()
	}
	if yyb309 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv312 := &x.ListMeta
		yym313 := z.DecBinary()
		_ = yym313
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv312) {
		} else {
			z.DecFallback(yyv312, false)
		}
	}
	yyj309++
	if yyhl309 {
		yyb309 = yyj309 > l
	} else {
		yyb309 = r.CheckBreak()
	}
	if yyb309 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv314 := &x.Items
		yym315 := z.DecBinary()
		_ = yym315
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv314), d)
		}
	}
	for {
		yyj309++
		if yyhl309 {
			yyb309 = yyj309 > l
		} else {
			yyb309 = r.CheckBreak()
		}
		if yyb309 {
			break
		}
		z.DecStructFieldNotFound(yyj309-1, "")
	}
	r.ReadEnd()
}

func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym316 := z.EncBinary()
		_ = yym316
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep317 := !z.EncBinary()
			yy2arr317 := z.EncBasicHandle().StructToArray
			var yyq317 [2]bool
			_, _, _ = yysep317, yyq317, yy2arr317
			const yyr317 bool = false
			yyq317[0] = x.Name != ""
			yyq317[1] = x.APIGroup != ""
			if yyr317 || yy2arr317 {
				r.EncodeArrayStart(2)
			} else {
				var yynn317 int = 0
				for _, b := range yyq317 {
					if b {
						yynn317++
					}
				}
				r.EncodeMapStart(yynn317)
			}
			if yyr317 || yy2arr317 {
				if yyq317[0] {
					yym319 := z.EncBinary()
					_ = yym319
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq317[0] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					yym320 := z.EncBinary()
					_ = yym320
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr317 || yy2arr317 {
				if yyq317[1] {
					yym322 := z.EncBinary()
					_ = yym322
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq317[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
					yym323 := z.EncBinary()
					_ = yym323
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				}
			}
			if yysep317 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym324 := z.DecBinary()
	_ = yym324
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl325 := r.ReadMapStart()
			if yyl325 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl325, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl325 := r.ReadArrayStart()
			if yyl325 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl325, 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 yys326Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys326Slc
	var yyhl326 bool = l >= 0
	for yyj326 := 0; ; yyj326++ {
		if yyhl326 {
			if yyj326 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys326Slc = r.DecodeBytes(yys326Slc, true, true)
		yys326 := string(yys326Slc)
		switch yys326 {
		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, yys326)
		} // end switch yys326
	} // end for yyj326
	if !yyhl326 {
		r.ReadEnd()
	}
}

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

func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym332 := z.EncBinary()
		_ = yym332
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep333 := !z.EncBinary()
			yy2arr333 := z.EncBasicHandle().StructToArray
			var yyq333 [4]bool
			_, _, _ = yysep333, yyq333, yy2arr333
			const yyr333 bool = false
			yyq333[0] = x.Kind != ""
			yyq333[1] = x.APIVersion != ""
			yyq333[2] = true
			yyq333[3] = len(x.Data) != 0
			if yyr333 || yy2arr333 {
				r.EncodeArrayStart(4)
			} else {
				var yynn333 int = 0
				for _, b := range yyq333 {
					if b {
						yynn333++
					}
				}
				r.EncodeMapStart(yynn333)
			}
			if yyr333 || yy2arr333 {
				if yyq333[0] {
					yym335 := z.EncBinary()
					_ = yym335
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq333[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym336 := z.EncBinary()
					_ = yym336
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr333 || yy2arr333 {
				if yyq333[1] {
					yym338 := z.EncBinary()
					_ = yym338
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq333[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym339 := z.EncBinary()
					_ = yym339
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr333 || yy2arr333 {
				if yyq333[2] {
					yy341 := &x.ObjectMeta
					yy341.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq333[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy342 := &x.ObjectMeta
					yy342.CodecEncodeSelf(e)
				}
			}
			if yyr333 || yy2arr333 {
				if yyq333[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym344 := z.EncBinary()
						_ = yym344
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq333[3] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym345 := z.EncBinary()
						_ = yym345
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yysep333 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym346 := z.DecBinary()
	_ = yym346
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl347 := r.ReadMapStart()
			if yyl347 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl347, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl347 := r.ReadArrayStart()
			if yyl347 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl347, 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 yys348Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys348Slc
	var yyhl348 bool = l >= 0
	for yyj348 := 0; ; yyj348++ {
		if yyhl348 {
			if yyj348 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys348Slc = r.DecodeBytes(yys348Slc, true, true)
		yys348 := string(yys348Slc)
		switch yys348 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv351 := &x.ObjectMeta
				yyv351.CodecDecodeSelf(d)
			}
		case "name":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv352 := &x.Data
				yym353 := z.DecBinary()
				_ = yym353
				if false {
				} else {
					*yyv352 = r.DecodeBytes(*(*[]byte)(yyv352), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys348)
		} // end switch yys348
	} // end for yyj348
	if !yyhl348 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj354 int
	var yyb354 bool
	var yyhl354 bool = l >= 0
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv357 := &x.ObjectMeta
		yyv357.CodecDecodeSelf(d)
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv358 := &x.Data
		yym359 := z.DecBinary()
		_ = yym359
		if false {
		} else {
			*yyv358 = r.DecodeBytes(*(*[]byte)(yyv358), false, false)
		}
	}
	for {
		yyj354++
		if yyhl354 {
			yyb354 = yyj354 > l
		} else {
			yyb354 = r.CheckBreak()
		}
		if yyb354 {
			break
		}
		z.DecStructFieldNotFound(yyj354-1, "")
	}
	r.ReadEnd()
}

func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym360 := z.EncBinary()
		_ = yym360
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep361 := !z.EncBinary()
			yy2arr361 := z.EncBasicHandle().StructToArray
			var yyq361 [5]bool
			_, _, _ = yysep361, yyq361, yy2arr361
			const yyr361 bool = false
			yyq361[0] = x.Kind != ""
			yyq361[1] = x.APIVersion != ""
			yyq361[2] = true
			yyq361[3] = true
			yyq361[4] = true
			if yyr361 || yy2arr361 {
				r.EncodeArrayStart(5)
			} else {
				var yynn361 int = 0
				for _, b := range yyq361 {
					if b {
						yynn361++
					}
				}
				r.EncodeMapStart(yynn361)
			}
			if yyr361 || yy2arr361 {
				if yyq361[0] {
					yym363 := z.EncBinary()
					_ = yym363
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq361[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym364 := z.EncBinary()
					_ = yym364
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr361 || yy2arr361 {
				if yyq361[1] {
					yym366 := z.EncBinary()
					_ = yym366
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq361[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym367 := z.EncBinary()
					_ = yym367
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr361 || yy2arr361 {
				if yyq361[2] {
					yy369 := &x.ObjectMeta
					yy369.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq361[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy370 := &x.ObjectMeta
					yy370.CodecEncodeSelf(e)
				}
			}
			if yyr361 || yy2arr361 {
				if yyq361[3] {
					yy372 := &x.Spec
					yy372.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq361[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy373 := &x.Spec
					yy373.CodecEncodeSelf(e)
				}
			}
			if yyr361 || yy2arr361 {
				if yyq361[4] {
					yy375 := &x.Status
					yy375.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq361[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy376 := &x.Status
					yy376.CodecEncodeSelf(e)
				}
			}
			if yysep361 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym377 := z.DecBinary()
	_ = yym377
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl378 := r.ReadMapStart()
			if yyl378 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl378, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl378 := r.ReadArrayStart()
			if yyl378 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl378, 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 yys379Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys379Slc
	var yyhl379 bool = l >= 0
	for yyj379 := 0; ; yyj379++ {
		if yyhl379 {
			if yyj379 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys379Slc = r.DecodeBytes(yys379Slc, true, true)
		yys379 := string(yys379Slc)
		switch yys379 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv382 := &x.ObjectMeta
				yyv382.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv383 := &x.Spec
				yyv383.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv384 := &x.Status
				yyv384.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys379)
		} // end switch yys379
	} // end for yyj379
	if !yyhl379 {
		r.ReadEnd()
	}
}

func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj385 int
	var yyb385 bool
	var yyhl385 bool = l >= 0
	yyj385++
	if yyhl385 {
		yyb385 = yyj385 > l
	} else {
		yyb385 = r.CheckBreak()
	}
	if yyb385 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj385++
	if yyhl385 {
		yyb385 = yyj385 > l
	} else {
		yyb385 = r.CheckBreak()
	}
	if yyb385 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj385++
	if yyhl385 {
		yyb385 = yyj385 > l
	} else {
		yyb385 = r.CheckBreak()
	}
	if yyb385 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv388 := &x.ObjectMeta
		yyv388.CodecDecodeSelf(d)
	}
	yyj385++
	if yyhl385 {
		yyb385 = yyj385 > l
	} else {
		yyb385 = r.CheckBreak()
	}
	if yyb385 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv389 := &x.Spec
		yyv389.CodecDecodeSelf(d)
	}
	yyj385++
	if yyhl385 {
		yyb385 = yyj385 > l
	} else {
		yyb385 = r.CheckBreak()
	}
	if yyb385 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv390 := &x.Status
		yyv390.CodecDecodeSelf(d)
	}
	for {
		yyj385++
		if yyhl385 {
			yyb385 = yyj385 > l
		} else {
			yyb385 = r.CheckBreak()
		}
		if yyb385 {
			break
		}
		z.DecStructFieldNotFound(yyj385-1, "")
	}
	r.ReadEnd()
}

func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym391 := z.EncBinary()
		_ = yym391
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep392 := !z.EncBinary()
			yy2arr392 := z.EncBasicHandle().StructToArray
			var yyq392 [5]bool
			_, _, _ = yysep392, yyq392, yy2arr392
			const yyr392 bool = false
			yyq392[0] = x.Replicas != 0
			yyq392[1] = len(x.Selector) != 0
			yyq392[3] = true
			yyq392[4] = x.UniqueLabelKey != ""
			if yyr392 || yy2arr392 {
				r.EncodeArrayStart(5)
			} else {
				var yynn392 int = 1
				for _, b := range yyq392 {
					if b {
						yynn392++
					}
				}
				r.EncodeMapStart(yynn392)
			}
			if yyr392 || yy2arr392 {
				if yyq392[0] {
					yym394 := z.EncBinary()
					_ = yym394
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq392[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym395 := z.EncBinary()
					_ = yym395
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr392 || yy2arr392 {
				if yyq392[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym397 := z.EncBinary()
						_ = yym397
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[1] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym398 := z.EncBinary()
						_ = yym398
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr392 || yy2arr392 {
				yy400 := &x.Template
				yy400.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy401 := &x.Template
				yy401.CodecEncodeSelf(e)
			}
			if yyr392 || yy2arr392 {
				if yyq392[3] {
					yy403 := &x.Strategy
					yy403.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[3] {
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					yy404 := &x.Strategy
					yy404.CodecEncodeSelf(e)
				}
			}
			if yyr392 || yy2arr392 {
				if yyq392[4] {
					yym406 := z.EncBinary()
					_ = yym406
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq392[4] {
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					yym407 := z.EncBinary()
					_ = yym407
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				}
			}
			if yysep392 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym408 := z.DecBinary()
	_ = yym408
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl409 := r.ReadMapStart()
			if yyl409 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl409, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl409 := r.ReadArrayStart()
			if yyl409 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl409, 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 yys410Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys410Slc
	var yyhl410 bool = l >= 0
	for yyj410 := 0; ; yyj410++ {
		if yyhl410 {
			if yyj410 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys410Slc = r.DecodeBytes(yys410Slc, true, true)
		yys410 := string(yys410Slc)
		switch yys410 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv412 := &x.Selector
				yym413 := z.DecBinary()
				_ = yym413
				if false {
				} else {
					z.F.DecMapStringStringX(yyv412, false, d)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv414 := &x.Template
				yyv414.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv415 := &x.Strategy
				yyv415.CodecDecodeSelf(d)
			}
		case "uniqueLabelKey":
			if r.TryDecodeAsNil() {
				x.UniqueLabelKey = ""
			} else {
				x.UniqueLabelKey = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys410)
		} // end switch yys410
	} // end for yyj410
	if !yyhl410 {
		r.ReadEnd()
	}
}

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj417 int
	var yyb417 bool
	var yyhl417 bool = l >= 0
	yyj417++
	if yyhl417 {
		yyb417 = yyj417 > l
	} else {
		yyb417 = r.CheckBreak()
	}
	if yyb417 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj417++
	if yyhl417 {
		yyb417 = yyj417 > l
	} else {
		yyb417 = r.CheckBreak()
	}
	if yyb417 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv419 := &x.Selector
		yym420 := z.DecBinary()
		_ = yym420
		if false {
		} else {
			z.F.DecMapStringStringX(yyv419, false, d)
		}
	}
	yyj417++
	if yyhl417 {
		yyb417 = yyj417 > l
	} else {
		yyb417 = r.CheckBreak()
	}
	if yyb417 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv421 := &x.Template
		yyv421.CodecDecodeSelf(d)
	}
	yyj417++
	if yyhl417 {
		yyb417 = yyj417 > l
	} else {
		yyb417 = r.CheckBreak()
	}
	if yyb417 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv422 := &x.Strategy
		yyv422.CodecDecodeSelf(d)
	}
	yyj417++
	if yyhl417 {
		yyb417 = yyj417 > l
	} else {
		yyb417 = r.CheckBreak()
	}
	if yyb417 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UniqueLabelKey = ""
	} else {
		x.UniqueLabelKey = string(r.DecodeString())
	}
	for {
		yyj417++
		if yyhl417 {
			yyb417 = yyj417 > l
		} else {
			yyb417 = r.CheckBreak()
		}
		if yyb417 {
			break
		}
		z.DecStructFieldNotFound(yyj417-1, "")
	}
	r.ReadEnd()
}

func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym424 := z.EncBinary()
		_ = yym424
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep425 := !z.EncBinary()
			yy2arr425 := z.EncBasicHandle().StructToArray
			var yyq425 [2]bool
			_, _, _ = yysep425, yyq425, yy2arr425
			const yyr425 bool = false
			yyq425[0] = x.Type != ""
			yyq425[1] = x.RollingUpdate != nil
			if yyr425 || yy2arr425 {
				r.EncodeArrayStart(2)
			} else {
				var yynn425 int = 0
				for _, b := range yyq425 {
					if b {
						yynn425++
					}
				}
				r.EncodeMapStart(yynn425)
			}
			if yyr425 || yy2arr425 {
				if yyq425[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq425[0] {
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr425 || yy2arr425 {
				if yyq425[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq425[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yysep425 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym428 := z.DecBinary()
	_ = yym428
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl429 := r.ReadMapStart()
			if yyl429 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl429, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl429 := r.ReadArrayStart()
			if yyl429 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl429, 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 yys430Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys430Slc
	var yyhl430 bool = l >= 0
	for yyj430 := 0; ; yyj430++ {
		if yyhl430 {
			if yyj430 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys430Slc = r.DecodeBytes(yys430Slc, true, true)
		yys430 := string(yys430Slc)
		switch yys430 {
		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, yys430)
		} // end switch yys430
	} // end for yyj430
	if !yyhl430 {
		r.ReadEnd()
	}
}

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

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym436 := z.EncBinary()
	_ = yym436
	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
	yym437 := z.DecBinary()
	_ = yym437
	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 {
		yym438 := z.EncBinary()
		_ = yym438
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep439 := !z.EncBinary()
			yy2arr439 := z.EncBasicHandle().StructToArray
			var yyq439 [3]bool
			_, _, _ = yysep439, yyq439, yy2arr439
			const yyr439 bool = false
			yyq439[0] = true
			yyq439[1] = true
			yyq439[2] = x.MinReadySeconds != 0
			if yyr439 || yy2arr439 {
				r.EncodeArrayStart(3)
			} else {
				var yynn439 int = 0
				for _, b := range yyq439 {
					if b {
						yynn439++
					}
				}
				r.EncodeMapStart(yynn439)
			}
			if yyr439 || yy2arr439 {
				if yyq439[0] {
					yy441 := &x.MaxUnavailable
					yym442 := z.EncBinary()
					_ = yym442
					if false {
					} else if z.HasExtensions() && z.EncExt(yy441) {
					} else if !yym442 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy441)
					} else {
						z.EncFallback(yy441)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq439[0] {
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					yy443 := &x.MaxUnavailable
					yym444 := z.EncBinary()
					_ = yym444
					if false {
					} else if z.HasExtensions() && z.EncExt(yy443) {
					} else if !yym444 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy443)
					} else {
						z.EncFallback(yy443)
					}
				}
			}
			if yyr439 || yy2arr439 {
				if yyq439[1] {
					yy446 := &x.MaxSurge
					yym447 := z.EncBinary()
					_ = yym447
					if false {
					} else if z.HasExtensions() && z.EncExt(yy446) {
					} else if !yym447 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy446)
					} else {
						z.EncFallback(yy446)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq439[1] {
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					yy448 := &x.MaxSurge
					yym449 := z.EncBinary()
					_ = yym449
					if false {
					} else if z.HasExtensions() && z.EncExt(yy448) {
					} else if !yym449 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy448)
					} else {
						z.EncFallback(yy448)
					}
				}
			}
			if yyr439 || yy2arr439 {
				if yyq439[2] {
					yym451 := z.EncBinary()
					_ = yym451
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq439[2] {
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					yym452 := z.EncBinary()
					_ = yym452
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yysep439 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym453 := z.DecBinary()
	_ = yym453
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl454 := r.ReadMapStart()
			if yyl454 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl454, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl454 := r.ReadArrayStart()
			if yyl454 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl454, 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 yys455Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys455Slc
	var yyhl455 bool = l >= 0
	for yyj455 := 0; ; yyj455++ {
		if yyhl455 {
			if yyj455 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys455Slc = r.DecodeBytes(yys455Slc, true, true)
		yys455 := string(yys455Slc)
		switch yys455 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				x.MaxUnavailable = pkg6_util.IntOrString{}
			} else {
				yyv456 := &x.MaxUnavailable
				yym457 := z.DecBinary()
				_ = yym457
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv456) {
				} else if !yym457 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv456)
				} else {
					z.DecFallback(yyv456, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				x.MaxSurge = pkg6_util.IntOrString{}
			} else {
				yyv458 := &x.MaxSurge
				yym459 := z.DecBinary()
				_ = yym459
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv458) {
				} else if !yym459 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv458)
				} else {
					z.DecFallback(yyv458, false)
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys455)
		} // end switch yys455
	} // end for yyj455
	if !yyhl455 {
		r.ReadEnd()
	}
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj461 int
	var yyb461 bool
	var yyhl461 bool = l >= 0
	yyj461++
	if yyhl461 {
		yyb461 = yyj461 > l
	} else {
		yyb461 = r.CheckBreak()
	}
	if yyb461 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg6_util.IntOrString{}
	} else {
		yyv462 := &x.MaxUnavailable
		yym463 := z.DecBinary()
		_ = yym463
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv462) {
		} else if !yym463 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv462)
		} else {
			z.DecFallback(yyv462, false)
		}
	}
	yyj461++
	if yyhl461 {
		yyb461 = yyj461 > l
	} else {
		yyb461 = r.CheckBreak()
	}
	if yyb461 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxSurge = pkg6_util.IntOrString{}
	} else {
		yyv464 := &x.MaxSurge
		yym465 := z.DecBinary()
		_ = yym465
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv464) {
		} else if !yym465 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv464)
		} else {
			z.DecFallback(yyv464, false)
		}
	}
	yyj461++
	if yyhl461 {
		yyb461 = yyj461 > l
	} else {
		yyb461 = r.CheckBreak()
	}
	if yyb461 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj461++
		if yyhl461 {
			yyb461 = yyj461 > l
		} else {
			yyb461 = r.CheckBreak()
		}
		if yyb461 {
			break
		}
		z.DecStructFieldNotFound(yyj461-1, "")
	}
	r.ReadEnd()
}

func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym467 := z.EncBinary()
		_ = yym467
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep468 := !z.EncBinary()
			yy2arr468 := z.EncBasicHandle().StructToArray
			var yyq468 [2]bool
			_, _, _ = yysep468, yyq468, yy2arr468
			const yyr468 bool = false
			yyq468[0] = x.Replicas != 0
			yyq468[1] = x.UpdatedReplicas != 0
			if yyr468 || yy2arr468 {
				r.EncodeArrayStart(2)
			} else {
				var yynn468 int = 0
				for _, b := range yyq468 {
					if b {
						yynn468++
					}
				}
				r.EncodeMapStart(yynn468)
			}
			if yyr468 || yy2arr468 {
				if yyq468[0] {
					yym470 := z.EncBinary()
					_ = yym470
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq468[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym471 := z.EncBinary()
					_ = yym471
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr468 || yy2arr468 {
				if yyq468[1] {
					yym473 := z.EncBinary()
					_ = yym473
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq468[1] {
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					yym474 := z.EncBinary()
					_ = yym474
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yysep468 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym475 := z.DecBinary()
	_ = yym475
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl476 := r.ReadMapStart()
			if yyl476 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl476, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl476 := r.ReadArrayStart()
			if yyl476 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl476, 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 yys477Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys477Slc
	var yyhl477 bool = l >= 0
	for yyj477 := 0; ; yyj477++ {
		if yyhl477 {
			if yyj477 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys477Slc = r.DecodeBytes(yys477Slc, true, true)
		yys477 := string(yys477Slc)
		switch yys477 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys477)
		} // end switch yys477
	} // end for yyj477
	if !yyhl477 {
		r.ReadEnd()
	}
}

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj480 int
	var yyb480 bool
	var yyhl480 bool = l >= 0
	yyj480++
	if yyhl480 {
		yyb480 = yyj480 > l
	} else {
		yyb480 = r.CheckBreak()
	}
	if yyb480 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj480++
	if yyhl480 {
		yyb480 = yyj480 > l
	} else {
		yyb480 = r.CheckBreak()
	}
	if yyb480 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj480++
		if yyhl480 {
			yyb480 = yyj480 > l
		} else {
			yyb480 = r.CheckBreak()
		}
		if yyb480 {
			break
		}
		z.DecStructFieldNotFound(yyj480-1, "")
	}
	r.ReadEnd()
}

func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym483 := z.EncBinary()
		_ = yym483
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep484 := !z.EncBinary()
			yy2arr484 := z.EncBasicHandle().StructToArray
			var yyq484 [4]bool
			_, _, _ = yysep484, yyq484, yy2arr484
			const yyr484 bool = false
			yyq484[0] = x.Kind != ""
			yyq484[1] = x.APIVersion != ""
			yyq484[2] = true
			if yyr484 || yy2arr484 {
				r.EncodeArrayStart(4)
			} else {
				var yynn484 int = 1
				for _, b := range yyq484 {
					if b {
						yynn484++
					}
				}
				r.EncodeMapStart(yynn484)
			}
			if yyr484 || yy2arr484 {
				if yyq484[0] {
					yym486 := z.EncBinary()
					_ = yym486
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq484[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym487 := z.EncBinary()
					_ = yym487
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr484 || yy2arr484 {
				if yyq484[1] {
					yym489 := z.EncBinary()
					_ = yym489
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq484[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym490 := z.EncBinary()
					_ = yym490
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr484 || yy2arr484 {
				if yyq484[2] {
					yy492 := &x.ListMeta
					yym493 := z.EncBinary()
					_ = yym493
					if false {
					} else if z.HasExtensions() && z.EncExt(yy492) {
					} else {
						z.EncFallback(yy492)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq484[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy494 := &x.ListMeta
					yym495 := z.EncBinary()
					_ = yym495
					if false {
					} else if z.HasExtensions() && z.EncExt(yy494) {
					} else {
						z.EncFallback(yy494)
					}
				}
			}
			if yyr484 || yy2arr484 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym497 := z.EncBinary()
					_ = yym497
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym498 := z.EncBinary()
					_ = yym498
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yysep484 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym499 := z.DecBinary()
	_ = yym499
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl500 := r.ReadMapStart()
			if yyl500 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl500, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl500 := r.ReadArrayStart()
			if yyl500 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl500, 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 yys501Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys501Slc
	var yyhl501 bool = l >= 0
	for yyj501 := 0; ; yyj501++ {
		if yyhl501 {
			if yyj501 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys501Slc = r.DecodeBytes(yys501Slc, true, true)
		yys501 := string(yys501Slc)
		switch yys501 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv504 := &x.ListMeta
				yym505 := z.DecBinary()
				_ = yym505
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv504) {
				} else {
					z.DecFallback(yyv504, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv506 := &x.Items
				yym507 := z.DecBinary()
				_ = yym507
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv506), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys501)
		} // end switch yys501
	} // end for yyj501
	if !yyhl501 {
		r.ReadEnd()
	}
}

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj508 int
	var yyb508 bool
	var yyhl508 bool = l >= 0
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv511 := &x.ListMeta
		yym512 := z.DecBinary()
		_ = yym512
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv511) {
		} else {
			z.DecFallback(yyv511, false)
		}
	}
	yyj508++
	if yyhl508 {
		yyb508 = yyj508 > l
	} else {
		yyb508 = r.CheckBreak()
	}
	if yyb508 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv513 := &x.Items
		yym514 := z.DecBinary()
		_ = yym514
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv513), d)
		}
	}
	for {
		yyj508++
		if yyhl508 {
			yyb508 = yyj508 > l
		} else {
			yyb508 = r.CheckBreak()
		}
		if yyb508 {
			break
		}
		z.DecStructFieldNotFound(yyj508-1, "")
	}
	r.ReadEnd()
}

func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym515 := z.EncBinary()
		_ = yym515
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep516 := !z.EncBinary()
			yy2arr516 := z.EncBasicHandle().StructToArray
			var yyq516 [2]bool
			_, _, _ = yysep516, yyq516, yy2arr516
			const yyr516 bool = false
			yyq516[0] = len(x.Selector) != 0
			yyq516[1] = x.Template != nil
			if yyr516 || yy2arr516 {
				r.EncodeArrayStart(2)
			} else {
				var yynn516 int = 0
				for _, b := range yyq516 {
					if b {
						yynn516++
					}
				}
				r.EncodeMapStart(yynn516)
			}
			if yyr516 || yy2arr516 {
				if yyq516[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym518 := z.EncBinary()
						_ = yym518
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq516[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym519 := z.EncBinary()
						_ = yym519
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr516 || yy2arr516 {
				if yyq516[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq516[1] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yysep516 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym521 := z.DecBinary()
	_ = yym521
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl522 := r.ReadMapStart()
			if yyl522 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl522, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl522 := r.ReadArrayStart()
			if yyl522 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl522, 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 yys523Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys523Slc
	var yyhl523 bool = l >= 0
	for yyj523 := 0; ; yyj523++ {
		if yyhl523 {
			if yyj523 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys523Slc = r.DecodeBytes(yys523Slc, true, true)
		yys523 := string(yys523Slc)
		switch yys523 {
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv524 := &x.Selector
				yym525 := z.DecBinary()
				_ = yym525
				if false {
				} else {
					z.F.DecMapStringStringX(yyv524, false, d)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				if x.Template != nil {
					x.Template = nil
				}
			} else {
				if x.Template == nil {
					x.Template = new(pkg2_api.PodTemplateSpec)
				}
				x.Template.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys523)
		} // end switch yys523
	} // end for yyj523
	if !yyhl523 {
		r.ReadEnd()
	}
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj527 int
	var yyb527 bool
	var yyhl527 bool = l >= 0
	yyj527++
	if yyhl527 {
		yyb527 = yyj527 > l
	} else {
		yyb527 = r.CheckBreak()
	}
	if yyb527 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv528 := &x.Selector
		yym529 := z.DecBinary()
		_ = yym529
		if false {
		} else {
			z.F.DecMapStringStringX(yyv528, false, d)
		}
	}
	yyj527++
	if yyhl527 {
		yyb527 = yyj527 > l
	} else {
		yyb527 = r.CheckBreak()
	}
	if yyb527 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_api.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj527++
		if yyhl527 {
			yyb527 = yyj527 > l
		} else {
			yyb527 = r.CheckBreak()
		}
		if yyb527 {
			break
		}
		z.DecStructFieldNotFound(yyj527-1, "")
	}
	r.ReadEnd()
}

func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym531 := z.EncBinary()
		_ = yym531
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep532 := !z.EncBinary()
			yy2arr532 := z.EncBasicHandle().StructToArray
			var yyq532 [3]bool
			_, _, _ = yysep532, yyq532, yy2arr532
			const yyr532 bool = false
			if yyr532 || yy2arr532 {
				r.EncodeArrayStart(3)
			} else {
				var yynn532 int = 3
				for _, b := range yyq532 {
					if b {
						yynn532++
					}
				}
				r.EncodeMapStart(yynn532)
			}
			if yyr532 || yy2arr532 {
				yym534 := z.EncBinary()
				_ = yym534
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym535 := z.EncBinary()
				_ = yym535
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr532 || yy2arr532 {
				yym537 := z.EncBinary()
				_ = yym537
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym538 := z.EncBinary()
				_ = yym538
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr532 || yy2arr532 {
				yym540 := z.EncBinary()
				_ = yym540
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym541 := z.EncBinary()
				_ = yym541
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep532 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym542 := z.DecBinary()
	_ = yym542
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl543 := r.ReadMapStart()
			if yyl543 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl543, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl543 := r.ReadArrayStart()
			if yyl543 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl543, 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 yys544Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys544Slc
	var yyhl544 bool = l >= 0
	for yyj544 := 0; ; yyj544++ {
		if yyhl544 {
			if yyj544 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys544Slc = r.DecodeBytes(yys544Slc, true, true)
		yys544 := string(yys544Slc)
		switch yys544 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys544)
		} // end switch yys544
	} // end for yyj544
	if !yyhl544 {
		r.ReadEnd()
	}
}

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj548 int
	var yyb548 bool
	var yyhl548 bool = l >= 0
	yyj548++
	if yyhl548 {
		yyb548 = yyj548 > l
	} else {
		yyb548 = r.CheckBreak()
	}
	if yyb548 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj548++
	if yyhl548 {
		yyb548 = yyj548 > l
	} else {
		yyb548 = r.CheckBreak()
	}
	if yyb548 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj548++
	if yyhl548 {
		yyb548 = yyj548 > l
	} else {
		yyb548 = r.CheckBreak()
	}
	if yyb548 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj548++
		if yyhl548 {
			yyb548 = yyj548 > l
		} else {
			yyb548 = r.CheckBreak()
		}
		if yyb548 {
			break
		}
		z.DecStructFieldNotFound(yyj548-1, "")
	}
	r.ReadEnd()
}

func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym552 := z.EncBinary()
		_ = yym552
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep553 := !z.EncBinary()
			yy2arr553 := z.EncBasicHandle().StructToArray
			var yyq553 [5]bool
			_, _, _ = yysep553, yyq553, yy2arr553
			const yyr553 bool = false
			yyq553[0] = x.Kind != ""
			yyq553[1] = x.APIVersion != ""
			yyq553[2] = true
			yyq553[3] = true
			yyq553[4] = true
			if yyr553 || yy2arr553 {
				r.EncodeArrayStart(5)
			} else {
				var yynn553 int = 0
				for _, b := range yyq553 {
					if b {
						yynn553++
					}
				}
				r.EncodeMapStart(yynn553)
			}
			if yyr553 || yy2arr553 {
				if yyq553[0] {
					yym555 := z.EncBinary()
					_ = yym555
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq553[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym556 := z.EncBinary()
					_ = yym556
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr553 || yy2arr553 {
				if yyq553[1] {
					yym558 := z.EncBinary()
					_ = yym558
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq553[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym559 := z.EncBinary()
					_ = yym559
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr553 || yy2arr553 {
				if yyq553[2] {
					yy561 := &x.ObjectMeta
					yy561.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq553[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy562 := &x.ObjectMeta
					yy562.CodecEncodeSelf(e)
				}
			}
			if yyr553 || yy2arr553 {
				if yyq553[3] {
					yy564 := &x.Spec
					yy564.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq553[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy565 := &x.Spec
					yy565.CodecEncodeSelf(e)
				}
			}
			if yyr553 || yy2arr553 {
				if yyq553[4] {
					yy567 := &x.Status
					yy567.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq553[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy568 := &x.Status
					yy568.CodecEncodeSelf(e)
				}
			}
			if yysep553 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym569 := z.DecBinary()
	_ = yym569
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl570 := r.ReadMapStart()
			if yyl570 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl570, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl570 := r.ReadArrayStart()
			if yyl570 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl570, 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 yys571Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys571Slc
	var yyhl571 bool = l >= 0
	for yyj571 := 0; ; yyj571++ {
		if yyhl571 {
			if yyj571 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys571Slc = r.DecodeBytes(yys571Slc, true, true)
		yys571 := string(yys571Slc)
		switch yys571 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv574 := &x.ObjectMeta
				yyv574.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv575 := &x.Spec
				yyv575.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv576 := &x.Status
				yyv576.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys571)
		} // end switch yys571
	} // end for yyj571
	if !yyhl571 {
		r.ReadEnd()
	}
}

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj577 int
	var yyb577 bool
	var yyhl577 bool = l >= 0
	yyj577++
	if yyhl577 {
		yyb577 = yyj577 > l
	} else {
		yyb577 = r.CheckBreak()
	}
	if yyb577 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj577++
	if yyhl577 {
		yyb577 = yyj577 > l
	} else {
		yyb577 = r.CheckBreak()
	}
	if yyb577 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj577++
	if yyhl577 {
		yyb577 = yyj577 > l
	} else {
		yyb577 = r.CheckBreak()
	}
	if yyb577 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv580 := &x.ObjectMeta
		yyv580.CodecDecodeSelf(d)
	}
	yyj577++
	if yyhl577 {
		yyb577 = yyj577 > l
	} else {
		yyb577 = r.CheckBreak()
	}
	if yyb577 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv581 := &x.Spec
		yyv581.CodecDecodeSelf(d)
	}
	yyj577++
	if yyhl577 {
		yyb577 = yyj577 > l
	} else {
		yyb577 = r.CheckBreak()
	}
	if yyb577 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv582 := &x.Status
		yyv582.CodecDecodeSelf(d)
	}
	for {
		yyj577++
		if yyhl577 {
			yyb577 = yyj577 > l
		} else {
			yyb577 = r.CheckBreak()
		}
		if yyb577 {
			break
		}
		z.DecStructFieldNotFound(yyj577-1, "")
	}
	r.ReadEnd()
}

func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym583 := z.EncBinary()
		_ = yym583
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep584 := !z.EncBinary()
			yy2arr584 := z.EncBasicHandle().StructToArray
			var yyq584 [4]bool
			_, _, _ = yysep584, yyq584, yy2arr584
			const yyr584 bool = false
			yyq584[0] = x.Kind != ""
			yyq584[1] = x.APIVersion != ""
			yyq584[2] = true
			if yyr584 || yy2arr584 {
				r.EncodeArrayStart(4)
			} else {
				var yynn584 int = 1
				for _, b := range yyq584 {
					if b {
						yynn584++
					}
				}
				r.EncodeMapStart(yynn584)
			}
			if yyr584 || yy2arr584 {
				if yyq584[0] {
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq584[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym587 := z.EncBinary()
					_ = yym587
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr584 || yy2arr584 {
				if yyq584[1] {
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq584[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr584 || yy2arr584 {
				if yyq584[2] {
					yy592 := &x.ListMeta
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else if z.HasExtensions() && z.EncExt(yy592) {
					} else {
						z.EncFallback(yy592)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq584[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy594 := &x.ListMeta
					yym595 := z.EncBinary()
					_ = yym595
					if false {
					} else if z.HasExtensions() && z.EncExt(yy594) {
					} else {
						z.EncFallback(yy594)
					}
				}
			}
			if yyr584 || yy2arr584 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym597 := z.EncBinary()
					_ = yym597
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym598 := z.EncBinary()
					_ = yym598
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep584 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym599 := z.DecBinary()
	_ = yym599
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl600 := r.ReadMapStart()
			if yyl600 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl600, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl600 := r.ReadArrayStart()
			if yyl600 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl600, 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 yys601Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys601Slc
	var yyhl601 bool = l >= 0
	for yyj601 := 0; ; yyj601++ {
		if yyhl601 {
			if yyj601 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys601Slc = r.DecodeBytes(yys601Slc, true, true)
		yys601 := string(yys601Slc)
		switch yys601 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv604 := &x.ListMeta
				yym605 := z.DecBinary()
				_ = yym605
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv604) {
				} else {
					z.DecFallback(yyv604, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv606 := &x.Items
				yym607 := z.DecBinary()
				_ = yym607
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv606), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys601)
		} // end switch yys601
	} // end for yyj601
	if !yyhl601 {
		r.ReadEnd()
	}
}

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj608 int
	var yyb608 bool
	var yyhl608 bool = l >= 0
	yyj608++
	if yyhl608 {
		yyb608 = yyj608 > l
	} else {
		yyb608 = r.CheckBreak()
	}
	if yyb608 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj608++
	if yyhl608 {
		yyb608 = yyj608 > l
	} else {
		yyb608 = r.CheckBreak()
	}
	if yyb608 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj608++
	if yyhl608 {
		yyb608 = yyj608 > l
	} else {
		yyb608 = r.CheckBreak()
	}
	if yyb608 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv611 := &x.ListMeta
		yym612 := z.DecBinary()
		_ = yym612
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv611) {
		} else {
			z.DecFallback(yyv611, false)
		}
	}
	yyj608++
	if yyhl608 {
		yyb608 = yyj608 > l
	} else {
		yyb608 = r.CheckBreak()
	}
	if yyb608 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv613 := &x.Items
		yym614 := z.DecBinary()
		_ = yym614
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv613), d)
		}
	}
	for {
		yyj608++
		if yyhl608 {
			yyb608 = yyj608 > l
		} else {
			yyb608 = r.CheckBreak()
		}
		if yyb608 {
			break
		}
		z.DecStructFieldNotFound(yyj608-1, "")
	}
	r.ReadEnd()
}

func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym615 := z.EncBinary()
		_ = yym615
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep616 := !z.EncBinary()
			yy2arr616 := z.EncBasicHandle().StructToArray
			var yyq616 [4]bool
			_, _, _ = yysep616, yyq616, yy2arr616
			const yyr616 bool = false
			yyq616[0] = x.Kind != ""
			yyq616[1] = x.APIVersion != ""
			yyq616[2] = true
			if yyr616 || yy2arr616 {
				r.EncodeArrayStart(4)
			} else {
				var yynn616 int = 1
				for _, b := range yyq616 {
					if b {
						yynn616++
					}
				}
				r.EncodeMapStart(yynn616)
			}
			if yyr616 || yy2arr616 {
				if yyq616[0] {
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq616[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym619 := z.EncBinary()
					_ = yym619
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr616 || yy2arr616 {
				if yyq616[1] {
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq616[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym622 := z.EncBinary()
					_ = yym622
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr616 || yy2arr616 {
				if yyq616[2] {
					yy624 := &x.ListMeta
					yym625 := z.EncBinary()
					_ = yym625
					if false {
					} else if z.HasExtensions() && z.EncExt(yy624) {
					} else {
						z.EncFallback(yy624)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq616[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy626 := &x.ListMeta
					yym627 := z.EncBinary()
					_ = yym627
					if false {
					} else if z.HasExtensions() && z.EncExt(yy626) {
					} else {
						z.EncFallback(yy626)
					}
				}
			}
			if yyr616 || yy2arr616 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym629 := z.EncBinary()
					_ = yym629
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym630 := z.EncBinary()
					_ = yym630
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep616 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym631 := z.DecBinary()
	_ = yym631
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl632 := r.ReadMapStart()
			if yyl632 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl632, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl632 := r.ReadArrayStart()
			if yyl632 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl632, 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 yys633Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys633Slc
	var yyhl633 bool = l >= 0
	for yyj633 := 0; ; yyj633++ {
		if yyhl633 {
			if yyj633 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys633Slc = r.DecodeBytes(yys633Slc, true, true)
		yys633 := string(yys633Slc)
		switch yys633 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv636 := &x.ListMeta
				yym637 := z.DecBinary()
				_ = yym637
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv636) {
				} else {
					z.DecFallback(yyv636, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv638 := &x.Items
				yym639 := z.DecBinary()
				_ = yym639
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv638), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys633)
		} // end switch yys633
	} // end for yyj633
	if !yyhl633 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj640 int
	var yyb640 bool
	var yyhl640 bool = l >= 0
	yyj640++
	if yyhl640 {
		yyb640 = yyj640 > l
	} else {
		yyb640 = r.CheckBreak()
	}
	if yyb640 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj640++
	if yyhl640 {
		yyb640 = yyj640 > l
	} else {
		yyb640 = r.CheckBreak()
	}
	if yyb640 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj640++
	if yyhl640 {
		yyb640 = yyj640 > l
	} else {
		yyb640 = r.CheckBreak()
	}
	if yyb640 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv643 := &x.ListMeta
		yym644 := z.DecBinary()
		_ = yym644
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv643) {
		} else {
			z.DecFallback(yyv643, false)
		}
	}
	yyj640++
	if yyhl640 {
		yyb640 = yyj640 > l
	} else {
		yyb640 = r.CheckBreak()
	}
	if yyb640 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv645 := &x.Items
		yym646 := z.DecBinary()
		_ = yym646
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv645), d)
		}
	}
	for {
		yyj640++
		if yyhl640 {
			yyb640 = yyj640 > l
		} else {
			yyb640 = r.CheckBreak()
		}
		if yyb640 {
			break
		}
		z.DecStructFieldNotFound(yyj640-1, "")
	}
	r.ReadEnd()
}

func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym647 := z.EncBinary()
		_ = yym647
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep648 := !z.EncBinary()
			yy2arr648 := z.EncBasicHandle().StructToArray
			var yyq648 [5]bool
			_, _, _ = yysep648, yyq648, yy2arr648
			const yyr648 bool = false
			yyq648[0] = x.Kind != ""
			yyq648[1] = x.APIVersion != ""
			yyq648[2] = true
			yyq648[3] = true
			yyq648[4] = true
			if yyr648 || yy2arr648 {
				r.EncodeArrayStart(5)
			} else {
				var yynn648 int = 0
				for _, b := range yyq648 {
					if b {
						yynn648++
					}
				}
				r.EncodeMapStart(yynn648)
			}
			if yyr648 || yy2arr648 {
				if yyq648[0] {
					yym650 := z.EncBinary()
					_ = yym650
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq648[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym651 := z.EncBinary()
					_ = yym651
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr648 || yy2arr648 {
				if yyq648[1] {
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq648[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym654 := z.EncBinary()
					_ = yym654
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr648 || yy2arr648 {
				if yyq648[2] {
					yy656 := &x.ObjectMeta
					yy656.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq648[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy657 := &x.ObjectMeta
					yy657.CodecEncodeSelf(e)
				}
			}
			if yyr648 || yy2arr648 {
				if yyq648[3] {
					yy659 := &x.Spec
					yy659.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq648[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy660 := &x.Spec
					yy660.CodecEncodeSelf(e)
				}
			}
			if yyr648 || yy2arr648 {
				if yyq648[4] {
					yy662 := &x.Status
					yy662.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq648[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy663 := &x.Status
					yy663.CodecEncodeSelf(e)
				}
			}
			if yysep648 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym664 := z.DecBinary()
	_ = yym664
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl665 := r.ReadMapStart()
			if yyl665 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl665, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl665 := r.ReadArrayStart()
			if yyl665 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl665, 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 yys666Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys666Slc
	var yyhl666 bool = l >= 0
	for yyj666 := 0; ; yyj666++ {
		if yyhl666 {
			if yyj666 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys666Slc = r.DecodeBytes(yys666Slc, true, true)
		yys666 := string(yys666Slc)
		switch yys666 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv669 := &x.ObjectMeta
				yyv669.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv670 := &x.Spec
				yyv670.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv671 := &x.Status
				yyv671.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys666)
		} // end switch yys666
	} // end for yyj666
	if !yyhl666 {
		r.ReadEnd()
	}
}

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj672 int
	var yyb672 bool
	var yyhl672 bool = l >= 0
	yyj672++
	if yyhl672 {
		yyb672 = yyj672 > l
	} else {
		yyb672 = r.CheckBreak()
	}
	if yyb672 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj672++
	if yyhl672 {
		yyb672 = yyj672 > l
	} else {
		yyb672 = r.CheckBreak()
	}
	if yyb672 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj672++
	if yyhl672 {
		yyb672 = yyj672 > l
	} else {
		yyb672 = r.CheckBreak()
	}
	if yyb672 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv675 := &x.ObjectMeta
		yyv675.CodecDecodeSelf(d)
	}
	yyj672++
	if yyhl672 {
		yyb672 = yyj672 > l
	} else {
		yyb672 = r.CheckBreak()
	}
	if yyb672 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv676 := &x.Spec
		yyv676.CodecDecodeSelf(d)
	}
	yyj672++
	if yyhl672 {
		yyb672 = yyj672 > l
	} else {
		yyb672 = r.CheckBreak()
	}
	if yyb672 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv677 := &x.Status
		yyv677.CodecDecodeSelf(d)
	}
	for {
		yyj672++
		if yyhl672 {
			yyb672 = yyj672 > l
		} else {
			yyb672 = r.CheckBreak()
		}
		if yyb672 {
			break
		}
		z.DecStructFieldNotFound(yyj672-1, "")
	}
	r.ReadEnd()
}

func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym678 := z.EncBinary()
		_ = yym678
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep679 := !z.EncBinary()
			yy2arr679 := z.EncBasicHandle().StructToArray
			var yyq679 [4]bool
			_, _, _ = yysep679, yyq679, yy2arr679
			const yyr679 bool = false
			yyq679[0] = x.Kind != ""
			yyq679[1] = x.APIVersion != ""
			yyq679[2] = true
			if yyr679 || yy2arr679 {
				r.EncodeArrayStart(4)
			} else {
				var yynn679 int = 1
				for _, b := range yyq679 {
					if b {
						yynn679++
					}
				}
				r.EncodeMapStart(yynn679)
			}
			if yyr679 || yy2arr679 {
				if yyq679[0] {
					yym681 := z.EncBinary()
					_ = yym681
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq679[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym682 := z.EncBinary()
					_ = yym682
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr679 || yy2arr679 {
				if yyq679[1] {
					yym684 := z.EncBinary()
					_ = yym684
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq679[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym685 := z.EncBinary()
					_ = yym685
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr679 || yy2arr679 {
				if yyq679[2] {
					yy687 := &x.ListMeta
					yym688 := z.EncBinary()
					_ = yym688
					if false {
					} else if z.HasExtensions() && z.EncExt(yy687) {
					} else {
						z.EncFallback(yy687)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq679[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy689 := &x.ListMeta
					yym690 := z.EncBinary()
					_ = yym690
					if false {
					} else if z.HasExtensions() && z.EncExt(yy689) {
					} else {
						z.EncFallback(yy689)
					}
				}
			}
			if yyr679 || yy2arr679 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym692 := z.EncBinary()
					_ = yym692
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym693 := z.EncBinary()
					_ = yym693
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep679 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym694 := z.DecBinary()
	_ = yym694
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl695 := r.ReadMapStart()
			if yyl695 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl695, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl695 := r.ReadArrayStart()
			if yyl695 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl695, 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 yys696Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys696Slc
	var yyhl696 bool = l >= 0
	for yyj696 := 0; ; yyj696++ {
		if yyhl696 {
			if yyj696 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys696Slc = r.DecodeBytes(yys696Slc, true, true)
		yys696 := string(yys696Slc)
		switch yys696 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv699 := &x.ListMeta
				yym700 := z.DecBinary()
				_ = yym700
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv699) {
				} else {
					z.DecFallback(yyv699, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv701 := &x.Items
				yym702 := z.DecBinary()
				_ = yym702
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv701), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys696)
		} // end switch yys696
	} // end for yyj696
	if !yyhl696 {
		r.ReadEnd()
	}
}

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj703 int
	var yyb703 bool
	var yyhl703 bool = l >= 0
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv706 := &x.ListMeta
		yym707 := z.DecBinary()
		_ = yym707
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv706) {
		} else {
			z.DecFallback(yyv706, false)
		}
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv708 := &x.Items
		yym709 := z.DecBinary()
		_ = yym709
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv708), d)
		}
	}
	for {
		yyj703++
		if yyhl703 {
			yyb703 = yyj703 > l
		} else {
			yyb703 = r.CheckBreak()
		}
		if yyb703 {
			break
		}
		z.DecStructFieldNotFound(yyj703-1, "")
	}
	r.ReadEnd()
}

func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym710 := z.EncBinary()
		_ = yym710
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep711 := !z.EncBinary()
			yy2arr711 := z.EncBasicHandle().StructToArray
			var yyq711 [4]bool
			_, _, _ = yysep711, yyq711, yy2arr711
			const yyr711 bool = false
			yyq711[0] = x.Parallelism != nil
			yyq711[1] = x.Completions != nil
			yyq711[2] = x.Selector != nil
			if yyr711 || yy2arr711 {
				r.EncodeArrayStart(4)
			} else {
				var yynn711 int = 1
				for _, b := range yyq711 {
					if b {
						yynn711++
					}
				}
				r.EncodeMapStart(yynn711)
			}
			if yyr711 || yy2arr711 {
				if yyq711[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy713 := *x.Parallelism
						yym714 := z.EncBinary()
						_ = yym714
						if false {
						} else {
							r.EncodeInt(int64(yy713))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq711[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy715 := *x.Parallelism
						yym716 := z.EncBinary()
						_ = yym716
						if false {
						} else {
							r.EncodeInt(int64(yy715))
						}
					}
				}
			}
			if yyr711 || yy2arr711 {
				if yyq711[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy718 := *x.Completions
						yym719 := z.EncBinary()
						_ = yym719
						if false {
						} else {
							r.EncodeInt(int64(yy718))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq711[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy720 := *x.Completions
						yym721 := z.EncBinary()
						_ = yym721
						if false {
						} else {
							r.EncodeInt(int64(yy720))
						}
					}
				}
			}
			if yyr711 || yy2arr711 {
				if yyq711[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq711[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr711 || yy2arr711 {
				yy724 := &x.Template
				yy724.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy725 := &x.Template
				yy725.CodecEncodeSelf(e)
			}
			if yysep711 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym726 := z.DecBinary()
	_ = yym726
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl727 := r.ReadMapStart()
			if yyl727 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl727, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl727 := r.ReadArrayStart()
			if yyl727 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl727, 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 yys728Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys728Slc
	var yyhl728 bool = l >= 0
	for yyj728 := 0; ; yyj728++ {
		if yyhl728 {
			if yyj728 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys728Slc = r.DecodeBytes(yys728Slc, true, true)
		yys728 := string(yys728Slc)
		switch yys728 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int)
				}
				yym730 := z.DecBinary()
				_ = yym730
				if false {
				} else {
					*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "completions":
			if r.TryDecodeAsNil() {
				if x.Completions != nil {
					x.Completions = nil
				}
			} else {
				if x.Completions == nil {
					x.Completions = new(int)
				}
				yym732 := z.DecBinary()
				_ = yym732
				if false {
				} else {
					*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(PodSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv734 := &x.Template
				yyv734.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys728)
		} // end switch yys728
	} // end for yyj728
	if !yyhl728 {
		r.ReadEnd()
	}
}

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj735 int
	var yyb735 bool
	var yyhl735 bool = l >= 0
	yyj735++
	if yyhl735 {
		yyb735 = yyj735 > l
	} else {
		yyb735 = r.CheckBreak()
	}
	if yyb735 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int)
		}
		yym737 := z.DecBinary()
		_ = yym737
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj735++
	if yyhl735 {
		yyb735 = yyj735 > l
	} else {
		yyb735 = r.CheckBreak()
	}
	if yyb735 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int)
		}
		yym739 := z.DecBinary()
		_ = yym739
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj735++
	if yyhl735 {
		yyb735 = yyj735 > l
	} else {
		yyb735 = r.CheckBreak()
	}
	if yyb735 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(PodSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj735++
	if yyhl735 {
		yyb735 = yyj735 > l
	} else {
		yyb735 = r.CheckBreak()
	}
	if yyb735 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv741 := &x.Template
		yyv741.CodecDecodeSelf(d)
	}
	for {
		yyj735++
		if yyhl735 {
			yyb735 = yyj735 > l
		} else {
			yyb735 = r.CheckBreak()
		}
		if yyb735 {
			break
		}
		z.DecStructFieldNotFound(yyj735-1, "")
	}
	r.ReadEnd()
}

func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym742 := z.EncBinary()
		_ = yym742
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep743 := !z.EncBinary()
			yy2arr743 := z.EncBasicHandle().StructToArray
			var yyq743 [6]bool
			_, _, _ = yysep743, yyq743, yy2arr743
			const yyr743 bool = false
			yyq743[0] = len(x.Conditions) != 0
			yyq743[1] = x.StartTime != nil
			yyq743[2] = x.CompletionTime != nil
			yyq743[3] = x.Active != 0
			yyq743[4] = x.Succeeded != 0
			yyq743[5] = x.Failed != 0
			if yyr743 || yy2arr743 {
				r.EncodeArrayStart(6)
			} else {
				var yynn743 int = 0
				for _, b := range yyq743 {
					if b {
						yynn743++
					}
				}
				r.EncodeMapStart(yynn743)
			}
			if yyr743 || yy2arr743 {
				if yyq743[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym745 := z.EncBinary()
						_ = yym745
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq743[0] {
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym746 := z.EncBinary()
						_ = yym746
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr743 || yy2arr743 {
				if yyq743[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym748 := z.EncBinary()
						_ = yym748
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym748 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym748 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq743[1] {
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym749 := z.EncBinary()
						_ = yym749
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym749 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym749 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr743 || yy2arr743 {
				if yyq743[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym751 := z.EncBinary()
						_ = yym751
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym751 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym751 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq743[2] {
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym752 := z.EncBinary()
						_ = yym752
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym752 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym752 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr743 || yy2arr743 {
				if yyq743[3] {
					yym754 := z.EncBinary()
					_ = yym754
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq743[3] {
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					yym755 := z.EncBinary()
					_ = yym755
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr743 || yy2arr743 {
				if yyq743[4] {
					yym757 := z.EncBinary()
					_ = yym757
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq743[4] {
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					yym758 := z.EncBinary()
					_ = yym758
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr743 || yy2arr743 {
				if yyq743[5] {
					yym760 := z.EncBinary()
					_ = yym760
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq743[5] {
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					yym761 := z.EncBinary()
					_ = yym761
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yysep743 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym762 := z.DecBinary()
	_ = yym762
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl763 := r.ReadMapStart()
			if yyl763 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl763, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl763 := r.ReadArrayStart()
			if yyl763 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl763, 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 yys764Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys764Slc
	var yyhl764 bool = l >= 0
	for yyj764 := 0; ; yyj764++ {
		if yyhl764 {
			if yyj764 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys764Slc = r.DecodeBytes(yys764Slc, true, true)
		yys764 := string(yys764Slc)
		switch yys764 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv765 := &x.Conditions
				yym766 := z.DecBinary()
				_ = yym766
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv765), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym768 := z.DecBinary()
				_ = yym768
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym768 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym768 && 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)
				}
				yym770 := z.DecBinary()
				_ = yym770
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym770 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym770 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.CompletionTime)
				} else {
					z.DecFallback(x.CompletionTime, false)
				}
			}
		case "active":
			if r.TryDecodeAsNil() {
				x.Active = 0
			} else {
				x.Active = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "succeeded":
			if r.TryDecodeAsNil() {
				x.Succeeded = 0
			} else {
				x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "failed":
			if r.TryDecodeAsNil() {
				x.Failed = 0
			} else {
				x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys764)
		} // end switch yys764
	} // end for yyj764
	if !yyhl764 {
		r.ReadEnd()
	}
}

func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj774 int
	var yyb774 bool
	var yyhl774 bool = l >= 0
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv775 := &x.Conditions
		yym776 := z.DecBinary()
		_ = yym776
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv775), d)
		}
	}
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.StartTime != nil {
			x.StartTime = nil
		}
	} else {
		if x.StartTime == nil {
			x.StartTime = new(pkg1_unversioned.Time)
		}
		yym778 := z.DecBinary()
		_ = yym778
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym778 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym778 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.CompletionTime != nil {
			x.CompletionTime = nil
		}
	} else {
		if x.CompletionTime == nil {
			x.CompletionTime = new(pkg1_unversioned.Time)
		}
		yym780 := z.DecBinary()
		_ = yym780
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym780 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym780 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj774++
	if yyhl774 {
		yyb774 = yyj774 > l
	} else {
		yyb774 = r.CheckBreak()
	}
	if yyb774 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj774++
		if yyhl774 {
			yyb774 = yyj774 > l
		} else {
			yyb774 = r.CheckBreak()
		}
		if yyb774 {
			break
		}
		z.DecStructFieldNotFound(yyj774-1, "")
	}
	r.ReadEnd()
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym784 := z.EncBinary()
	_ = yym784
	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
	yym785 := z.DecBinary()
	_ = yym785
	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 {
		yym786 := z.EncBinary()
		_ = yym786
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep787 := !z.EncBinary()
			yy2arr787 := z.EncBasicHandle().StructToArray
			var yyq787 [6]bool
			_, _, _ = yysep787, yyq787, yy2arr787
			const yyr787 bool = false
			yyq787[2] = true
			yyq787[3] = true
			yyq787[4] = x.Reason != ""
			yyq787[5] = x.Message != ""
			if yyr787 || yy2arr787 {
				r.EncodeArrayStart(6)
			} else {
				var yynn787 int = 2
				for _, b := range yyq787 {
					if b {
						yynn787++
					}
				}
				r.EncodeMapStart(yynn787)
			}
			if yyr787 || yy2arr787 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr787 || yy2arr787 {
				yym790 := z.EncBinary()
				_ = yym790
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				yym791 := z.EncBinary()
				_ = yym791
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr787 || yy2arr787 {
				if yyq787[2] {
					yy793 := &x.LastProbeTime
					yym794 := z.EncBinary()
					_ = yym794
					if false {
					} else if z.HasExtensions() && z.EncExt(yy793) {
					} else if yym794 {
						z.EncBinaryMarshal(yy793)
					} else if !yym794 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy793)
					} else {
						z.EncFallback(yy793)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq787[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy795 := &x.LastProbeTime
					yym796 := z.EncBinary()
					_ = yym796
					if false {
					} else if z.HasExtensions() && z.EncExt(yy795) {
					} else if yym796 {
						z.EncBinaryMarshal(yy795)
					} else if !yym796 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy795)
					} else {
						z.EncFallback(yy795)
					}
				}
			}
			if yyr787 || yy2arr787 {
				if yyq787[3] {
					yy798 := &x.LastTransitionTime
					yym799 := z.EncBinary()
					_ = yym799
					if false {
					} else if z.HasExtensions() && z.EncExt(yy798) {
					} else if yym799 {
						z.EncBinaryMarshal(yy798)
					} else if !yym799 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy798)
					} else {
						z.EncFallback(yy798)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq787[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy800 := &x.LastTransitionTime
					yym801 := z.EncBinary()
					_ = yym801
					if false {
					} else if z.HasExtensions() && z.EncExt(yy800) {
					} else if yym801 {
						z.EncBinaryMarshal(yy800)
					} else if !yym801 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy800)
					} else {
						z.EncFallback(yy800)
					}
				}
			}
			if yyr787 || yy2arr787 {
				if yyq787[4] {
					yym803 := z.EncBinary()
					_ = yym803
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq787[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym804 := z.EncBinary()
					_ = yym804
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr787 || yy2arr787 {
				if yyq787[5] {
					yym806 := z.EncBinary()
					_ = yym806
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq787[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym807 := z.EncBinary()
					_ = yym807
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep787 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym808 := z.DecBinary()
	_ = yym808
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl809 := r.ReadMapStart()
			if yyl809 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl809, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl809 := r.ReadArrayStart()
			if yyl809 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl809, 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 yys810Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys810Slc
	var yyhl810 bool = l >= 0
	for yyj810 := 0; ; yyj810++ {
		if yyhl810 {
			if yyj810 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys810Slc = r.DecodeBytes(yys810Slc, true, true)
		yys810 := string(yys810Slc)
		switch yys810 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = JobConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_api.ConditionStatus(r.DecodeString())
			}
		case "lastProbeTime":
			if r.TryDecodeAsNil() {
				x.LastProbeTime = pkg1_unversioned.Time{}
			} else {
				yyv813 := &x.LastProbeTime
				yym814 := z.DecBinary()
				_ = yym814
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv813) {
				} else if yym814 {
					z.DecBinaryUnmarshal(yyv813)
				} else if !yym814 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv813)
				} else {
					z.DecFallback(yyv813, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv815 := &x.LastTransitionTime
				yym816 := z.DecBinary()
				_ = yym816
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv815) {
				} else if yym816 {
					z.DecBinaryUnmarshal(yyv815)
				} else if !yym816 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv815)
				} else {
					z.DecFallback(yyv815, 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, yys810)
		} // end switch yys810
	} // end for yyj810
	if !yyhl810 {
		r.ReadEnd()
	}
}

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj819 int
	var yyb819 bool
	var yyhl819 bool = l >= 0
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_api.ConditionStatus(r.DecodeString())
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv822 := &x.LastProbeTime
		yym823 := z.DecBinary()
		_ = yym823
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv822) {
		} else if yym823 {
			z.DecBinaryUnmarshal(yyv822)
		} else if !yym823 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv822)
		} else {
			z.DecFallback(yyv822, false)
		}
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv824 := &x.LastTransitionTime
		yym825 := z.DecBinary()
		_ = yym825
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv824) {
		} else if yym825 {
			z.DecBinaryUnmarshal(yyv824)
		} else if !yym825 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv824)
		} else {
			z.DecFallback(yyv824, false)
		}
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj819++
	if yyhl819 {
		yyb819 = yyj819 > l
	} else {
		yyb819 = r.CheckBreak()
	}
	if yyb819 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj819++
		if yyhl819 {
			yyb819 = yyj819 > l
		} else {
			yyb819 = r.CheckBreak()
		}
		if yyb819 {
			break
		}
		z.DecStructFieldNotFound(yyj819-1, "")
	}
	r.ReadEnd()
}

func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym828 := z.EncBinary()
		_ = yym828
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep829 := !z.EncBinary()
			yy2arr829 := z.EncBasicHandle().StructToArray
			var yyq829 [5]bool
			_, _, _ = yysep829, yyq829, yy2arr829
			const yyr829 bool = false
			yyq829[0] = x.Kind != ""
			yyq829[1] = x.APIVersion != ""
			yyq829[2] = true
			yyq829[3] = true
			yyq829[4] = true
			if yyr829 || yy2arr829 {
				r.EncodeArrayStart(5)
			} else {
				var yynn829 int = 0
				for _, b := range yyq829 {
					if b {
						yynn829++
					}
				}
				r.EncodeMapStart(yynn829)
			}
			if yyr829 || yy2arr829 {
				if yyq829[0] {
					yym831 := z.EncBinary()
					_ = yym831
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq829[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym832 := z.EncBinary()
					_ = yym832
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr829 || yy2arr829 {
				if yyq829[1] {
					yym834 := z.EncBinary()
					_ = yym834
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq829[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym835 := z.EncBinary()
					_ = yym835
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr829 || yy2arr829 {
				if yyq829[2] {
					yy837 := &x.ObjectMeta
					yy837.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq829[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy838 := &x.ObjectMeta
					yy838.CodecEncodeSelf(e)
				}
			}
			if yyr829 || yy2arr829 {
				if yyq829[3] {
					yy840 := &x.Spec
					yy840.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq829[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy841 := &x.Spec
					yy841.CodecEncodeSelf(e)
				}
			}
			if yyr829 || yy2arr829 {
				if yyq829[4] {
					yy843 := &x.Status
					yy843.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq829[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy844 := &x.Status
					yy844.CodecEncodeSelf(e)
				}
			}
			if yysep829 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym845 := z.DecBinary()
	_ = yym845
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl846 := r.ReadMapStart()
			if yyl846 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl846, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl846 := r.ReadArrayStart()
			if yyl846 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl846, 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 yys847Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys847Slc
	var yyhl847 bool = l >= 0
	for yyj847 := 0; ; yyj847++ {
		if yyhl847 {
			if yyj847 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys847Slc = r.DecodeBytes(yys847Slc, true, true)
		yys847 := string(yys847Slc)
		switch yys847 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv850 := &x.ObjectMeta
				yyv850.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv851 := &x.Spec
				yyv851.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv852 := &x.Status
				yyv852.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys847)
		} // end switch yys847
	} // end for yyj847
	if !yyhl847 {
		r.ReadEnd()
	}
}

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj853 int
	var yyb853 bool
	var yyhl853 bool = l >= 0
	yyj853++
	if yyhl853 {
		yyb853 = yyj853 > l
	} else {
		yyb853 = r.CheckBreak()
	}
	if yyb853 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj853++
	if yyhl853 {
		yyb853 = yyj853 > l
	} else {
		yyb853 = r.CheckBreak()
	}
	if yyb853 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj853++
	if yyhl853 {
		yyb853 = yyj853 > l
	} else {
		yyb853 = r.CheckBreak()
	}
	if yyb853 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv856 := &x.ObjectMeta
		yyv856.CodecDecodeSelf(d)
	}
	yyj853++
	if yyhl853 {
		yyb853 = yyj853 > l
	} else {
		yyb853 = r.CheckBreak()
	}
	if yyb853 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv857 := &x.Spec
		yyv857.CodecDecodeSelf(d)
	}
	yyj853++
	if yyhl853 {
		yyb853 = yyj853 > l
	} else {
		yyb853 = r.CheckBreak()
	}
	if yyb853 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv858 := &x.Status
		yyv858.CodecDecodeSelf(d)
	}
	for {
		yyj853++
		if yyhl853 {
			yyb853 = yyj853 > l
		} else {
			yyb853 = r.CheckBreak()
		}
		if yyb853 {
			break
		}
		z.DecStructFieldNotFound(yyj853-1, "")
	}
	r.ReadEnd()
}

func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym859 := z.EncBinary()
		_ = yym859
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep860 := !z.EncBinary()
			yy2arr860 := z.EncBasicHandle().StructToArray
			var yyq860 [4]bool
			_, _, _ = yysep860, yyq860, yy2arr860
			const yyr860 bool = false
			yyq860[0] = x.Kind != ""
			yyq860[1] = x.APIVersion != ""
			yyq860[2] = true
			if yyr860 || yy2arr860 {
				r.EncodeArrayStart(4)
			} else {
				var yynn860 int = 1
				for _, b := range yyq860 {
					if b {
						yynn860++
					}
				}
				r.EncodeMapStart(yynn860)
			}
			if yyr860 || yy2arr860 {
				if yyq860[0] {
					yym862 := z.EncBinary()
					_ = yym862
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq860[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym863 := z.EncBinary()
					_ = yym863
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr860 || yy2arr860 {
				if yyq860[1] {
					yym865 := z.EncBinary()
					_ = yym865
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq860[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym866 := z.EncBinary()
					_ = yym866
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr860 || yy2arr860 {
				if yyq860[2] {
					yy868 := &x.ListMeta
					yym869 := z.EncBinary()
					_ = yym869
					if false {
					} else if z.HasExtensions() && z.EncExt(yy868) {
					} else {
						z.EncFallback(yy868)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq860[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy870 := &x.ListMeta
					yym871 := z.EncBinary()
					_ = yym871
					if false {
					} else if z.HasExtensions() && z.EncExt(yy870) {
					} else {
						z.EncFallback(yy870)
					}
				}
			}
			if yyr860 || yy2arr860 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym873 := z.EncBinary()
					_ = yym873
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym874 := z.EncBinary()
					_ = yym874
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep860 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym875 := z.DecBinary()
	_ = yym875
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl876 := r.ReadMapStart()
			if yyl876 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl876, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl876 := r.ReadArrayStart()
			if yyl876 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl876, 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 yys877Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys877Slc
	var yyhl877 bool = l >= 0
	for yyj877 := 0; ; yyj877++ {
		if yyhl877 {
			if yyj877 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys877Slc = r.DecodeBytes(yys877Slc, true, true)
		yys877 := string(yys877Slc)
		switch yys877 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv880 := &x.ListMeta
				yym881 := z.DecBinary()
				_ = yym881
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv880) {
				} else {
					z.DecFallback(yyv880, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv882 := &x.Items
				yym883 := z.DecBinary()
				_ = yym883
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv882), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys877)
		} // end switch yys877
	} // end for yyj877
	if !yyhl877 {
		r.ReadEnd()
	}
}

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj884 int
	var yyb884 bool
	var yyhl884 bool = l >= 0
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv887 := &x.ListMeta
		yym888 := z.DecBinary()
		_ = yym888
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv887) {
		} else {
			z.DecFallback(yyv887, false)
		}
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv889 := &x.Items
		yym890 := z.DecBinary()
		_ = yym890
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv889), d)
		}
	}
	for {
		yyj884++
		if yyhl884 {
			yyb884 = yyj884 > l
		} else {
			yyb884 = r.CheckBreak()
		}
		if yyb884 {
			break
		}
		z.DecStructFieldNotFound(yyj884-1, "")
	}
	r.ReadEnd()
}

func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym891 := z.EncBinary()
		_ = yym891
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep892 := !z.EncBinary()
			yy2arr892 := z.EncBasicHandle().StructToArray
			var yyq892 [2]bool
			_, _, _ = yysep892, yyq892, yy2arr892
			const yyr892 bool = false
			yyq892[0] = x.Backend != nil
			yyq892[1] = len(x.Rules) != 0
			if yyr892 || yy2arr892 {
				r.EncodeArrayStart(2)
			} else {
				var yynn892 int = 0
				for _, b := range yyq892 {
					if b {
						yynn892++
					}
				}
				r.EncodeMapStart(yynn892)
			}
			if yyr892 || yy2arr892 {
				if yyq892[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq892[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr892 || yy2arr892 {
				if yyq892[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym895 := z.EncBinary()
						_ = yym895
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq892[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym896 := z.EncBinary()
						_ = yym896
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep892 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym897 := z.DecBinary()
	_ = yym897
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl898 := r.ReadMapStart()
			if yyl898 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl898, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl898 := r.ReadArrayStart()
			if yyl898 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl898, 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 yys899Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys899Slc
	var yyhl899 bool = l >= 0
	for yyj899 := 0; ; yyj899++ {
		if yyhl899 {
			if yyj899 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys899Slc = r.DecodeBytes(yys899Slc, true, true)
		yys899 := string(yys899Slc)
		switch yys899 {
		case "backend":
			if r.TryDecodeAsNil() {
				if x.Backend != nil {
					x.Backend = nil
				}
			} else {
				if x.Backend == nil {
					x.Backend = new(IngressBackend)
				}
				x.Backend.CodecDecodeSelf(d)
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv901 := &x.Rules
				yym902 := z.DecBinary()
				_ = yym902
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv901), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys899)
		} // end switch yys899
	} // end for yyj899
	if !yyhl899 {
		r.ReadEnd()
	}
}

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj903 int
	var yyb903 bool
	var yyhl903 bool = l >= 0
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Backend != nil {
			x.Backend = nil
		}
	} else {
		if x.Backend == nil {
			x.Backend = new(IngressBackend)
		}
		x.Backend.CodecDecodeSelf(d)
	}
	yyj903++
	if yyhl903 {
		yyb903 = yyj903 > l
	} else {
		yyb903 = r.CheckBreak()
	}
	if yyb903 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv905 := &x.Rules
		yym906 := z.DecBinary()
		_ = yym906
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv905), d)
		}
	}
	for {
		yyj903++
		if yyhl903 {
			yyb903 = yyj903 > l
		} else {
			yyb903 = r.CheckBreak()
		}
		if yyb903 {
			break
		}
		z.DecStructFieldNotFound(yyj903-1, "")
	}
	r.ReadEnd()
}

func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym907 := z.EncBinary()
		_ = yym907
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep908 := !z.EncBinary()
			yy2arr908 := z.EncBasicHandle().StructToArray
			var yyq908 [1]bool
			_, _, _ = yysep908, yyq908, yy2arr908
			const yyr908 bool = false
			yyq908[0] = true
			if yyr908 || yy2arr908 {
				r.EncodeArrayStart(1)
			} else {
				var yynn908 int = 0
				for _, b := range yyq908 {
					if b {
						yynn908++
					}
				}
				r.EncodeMapStart(yynn908)
			}
			if yyr908 || yy2arr908 {
				if yyq908[0] {
					yy910 := &x.LoadBalancer
					yy910.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq908[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy911 := &x.LoadBalancer
					yy911.CodecEncodeSelf(e)
				}
			}
			if yysep908 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym912 := z.DecBinary()
	_ = yym912
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl913 := r.ReadMapStart()
			if yyl913 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl913, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl913 := r.ReadArrayStart()
			if yyl913 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl913, 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 yys914Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys914Slc
	var yyhl914 bool = l >= 0
	for yyj914 := 0; ; yyj914++ {
		if yyhl914 {
			if yyj914 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys914Slc = r.DecodeBytes(yys914Slc, true, true)
		yys914 := string(yys914Slc)
		switch yys914 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
			} else {
				yyv915 := &x.LoadBalancer
				yyv915.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys914)
		} // end switch yys914
	} // end for yyj914
	if !yyhl914 {
		r.ReadEnd()
	}
}

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj916 int
	var yyb916 bool
	var yyhl916 bool = l >= 0
	yyj916++
	if yyhl916 {
		yyb916 = yyj916 > l
	} else {
		yyb916 = r.CheckBreak()
	}
	if yyb916 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv917 := &x.LoadBalancer
		yyv917.CodecDecodeSelf(d)
	}
	for {
		yyj916++
		if yyhl916 {
			yyb916 = yyj916 > l
		} else {
			yyb916 = r.CheckBreak()
		}
		if yyb916 {
			break
		}
		z.DecStructFieldNotFound(yyj916-1, "")
	}
	r.ReadEnd()
}

func (x *IngressRule) 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 [2]bool
			_, _, _ = yysep919, yyq919, yy2arr919
			const yyr919 bool = false
			yyq919[0] = x.Host != ""
			yyq919[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr919 || yy2arr919 {
				r.EncodeArrayStart(2)
			} else {
				var yynn919 int = 0
				for _, b := range yyq919 {
					if b {
						yynn919++
					}
				}
				r.EncodeMapStart(yynn919)
			}
			if yyr919 || yy2arr919 {
				if yyq919[0] {
					yym921 := z.EncBinary()
					_ = yym921
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq919[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym922 := z.EncBinary()
					_ = yym922
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn923 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn923 = true
				goto LABEL923
			}
		LABEL923:
			if yyr919 || yy2arr919 {
				if yyn923 {
					r.EncodeNil()
				} else {
					if yyq919[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq919[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn923 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep919 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym924 := z.DecBinary()
	_ = yym924
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl925 := r.ReadMapStart()
			if yyl925 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl925, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl925 := r.ReadArrayStart()
			if yyl925 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl925, 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 yys926Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys926Slc
	var yyhl926 bool = l >= 0
	for yyj926 := 0; ; yyj926++ {
		if yyhl926 {
			if yyj926 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys926Slc = r.DecodeBytes(yys926Slc, true, true)
		yys926 := string(yys926Slc)
		switch yys926 {
		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, yys926)
		} // end switch yys926
	} // end for yyj926
	if !yyhl926 {
		r.ReadEnd()
	}
}

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

func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym932 := z.EncBinary()
		_ = yym932
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep933 := !z.EncBinary()
			yy2arr933 := z.EncBasicHandle().StructToArray
			var yyq933 [1]bool
			_, _, _ = yysep933, yyq933, yy2arr933
			const yyr933 bool = false
			yyq933[0] = x.HTTP != nil
			if yyr933 || yy2arr933 {
				r.EncodeArrayStart(1)
			} else {
				var yynn933 int = 0
				for _, b := range yyq933 {
					if b {
						yynn933++
					}
				}
				r.EncodeMapStart(yynn933)
			}
			if yyr933 || yy2arr933 {
				if yyq933[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq933[0] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				}
			}
			if yysep933 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym935 := z.DecBinary()
	_ = yym935
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl936 := r.ReadMapStart()
			if yyl936 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl936, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl936 := r.ReadArrayStart()
			if yyl936 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl936, 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 yys937Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys937Slc
	var yyhl937 bool = l >= 0
	for yyj937 := 0; ; yyj937++ {
		if yyhl937 {
			if yyj937 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys937Slc = r.DecodeBytes(yys937Slc, true, true)
		yys937 := string(yys937Slc)
		switch yys937 {
		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, yys937)
		} // end switch yys937
	} // end for yyj937
	if !yyhl937 {
		r.ReadEnd()
	}
}

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

func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym941 := z.EncBinary()
		_ = yym941
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep942 := !z.EncBinary()
			yy2arr942 := z.EncBasicHandle().StructToArray
			var yyq942 [1]bool
			_, _, _ = yysep942, yyq942, yy2arr942
			const yyr942 bool = false
			if yyr942 || yy2arr942 {
				r.EncodeArrayStart(1)
			} else {
				var yynn942 int = 1
				for _, b := range yyq942 {
					if b {
						yynn942++
					}
				}
				r.EncodeMapStart(yynn942)
			}
			if yyr942 || yy2arr942 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym944 := z.EncBinary()
					_ = yym944
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym945 := z.EncBinary()
					_ = yym945
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep942 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym946 := z.DecBinary()
	_ = yym946
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl947 := r.ReadMapStart()
			if yyl947 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl947, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl947 := r.ReadArrayStart()
			if yyl947 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl947, 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 yys948Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys948Slc
	var yyhl948 bool = l >= 0
	for yyj948 := 0; ; yyj948++ {
		if yyhl948 {
			if yyj948 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys948Slc = r.DecodeBytes(yys948Slc, true, true)
		yys948 := string(yys948Slc)
		switch yys948 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv949 := &x.Paths
				yym950 := z.DecBinary()
				_ = yym950
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv949), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys948)
		} // end switch yys948
	} // end for yyj948
	if !yyhl948 {
		r.ReadEnd()
	}
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj951 int
	var yyb951 bool
	var yyhl951 bool = l >= 0
	yyj951++
	if yyhl951 {
		yyb951 = yyj951 > l
	} else {
		yyb951 = r.CheckBreak()
	}
	if yyb951 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv952 := &x.Paths
		yym953 := z.DecBinary()
		_ = yym953
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv952), d)
		}
	}
	for {
		yyj951++
		if yyhl951 {
			yyb951 = yyj951 > l
		} else {
			yyb951 = r.CheckBreak()
		}
		if yyb951 {
			break
		}
		z.DecStructFieldNotFound(yyj951-1, "")
	}
	r.ReadEnd()
}

func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym954 := z.EncBinary()
		_ = yym954
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep955 := !z.EncBinary()
			yy2arr955 := z.EncBasicHandle().StructToArray
			var yyq955 [2]bool
			_, _, _ = yysep955, yyq955, yy2arr955
			const yyr955 bool = false
			yyq955[0] = x.Path != ""
			if yyr955 || yy2arr955 {
				r.EncodeArrayStart(2)
			} else {
				var yynn955 int = 1
				for _, b := range yyq955 {
					if b {
						yynn955++
					}
				}
				r.EncodeMapStart(yynn955)
			}
			if yyr955 || yy2arr955 {
				if yyq955[0] {
					yym957 := z.EncBinary()
					_ = yym957
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq955[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym958 := z.EncBinary()
					_ = yym958
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr955 || yy2arr955 {
				yy960 := &x.Backend
				yy960.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy961 := &x.Backend
				yy961.CodecEncodeSelf(e)
			}
			if yysep955 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym962 := z.DecBinary()
	_ = yym962
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl963 := r.ReadMapStart()
			if yyl963 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl963, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl963 := r.ReadArrayStart()
			if yyl963 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl963, 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 yys964Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys964Slc
	var yyhl964 bool = l >= 0
	for yyj964 := 0; ; yyj964++ {
		if yyhl964 {
			if yyj964 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys964Slc = r.DecodeBytes(yys964Slc, true, true)
		yys964 := string(yys964Slc)
		switch yys964 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv966 := &x.Backend
				yyv966.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys964)
		} // end switch yys964
	} // end for yyj964
	if !yyhl964 {
		r.ReadEnd()
	}
}

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj967 int
	var yyb967 bool
	var yyhl967 bool = l >= 0
	yyj967++
	if yyhl967 {
		yyb967 = yyj967 > l
	} else {
		yyb967 = r.CheckBreak()
	}
	if yyb967 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj967++
	if yyhl967 {
		yyb967 = yyj967 > l
	} else {
		yyb967 = r.CheckBreak()
	}
	if yyb967 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv969 := &x.Backend
		yyv969.CodecDecodeSelf(d)
	}
	for {
		yyj967++
		if yyhl967 {
			yyb967 = yyj967 > l
		} else {
			yyb967 = r.CheckBreak()
		}
		if yyb967 {
			break
		}
		z.DecStructFieldNotFound(yyj967-1, "")
	}
	r.ReadEnd()
}

func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym970 := z.EncBinary()
		_ = yym970
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep971 := !z.EncBinary()
			yy2arr971 := z.EncBasicHandle().StructToArray
			var yyq971 [2]bool
			_, _, _ = yysep971, yyq971, yy2arr971
			const yyr971 bool = false
			if yyr971 || yy2arr971 {
				r.EncodeArrayStart(2)
			} else {
				var yynn971 int = 2
				for _, b := range yyq971 {
					if b {
						yynn971++
					}
				}
				r.EncodeMapStart(yynn971)
			}
			if yyr971 || yy2arr971 {
				yym973 := z.EncBinary()
				_ = yym973
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym974 := z.EncBinary()
				_ = yym974
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr971 || yy2arr971 {
				yy976 := &x.ServicePort
				yym977 := z.EncBinary()
				_ = yym977
				if false {
				} else if z.HasExtensions() && z.EncExt(yy976) {
				} else if !yym977 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy976)
				} else {
					z.EncFallback(yy976)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy978 := &x.ServicePort
				yym979 := z.EncBinary()
				_ = yym979
				if false {
				} else if z.HasExtensions() && z.EncExt(yy978) {
				} else if !yym979 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy978)
				} else {
					z.EncFallback(yy978)
				}
			}
			if yysep971 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym980 := z.DecBinary()
	_ = yym980
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl981 := r.ReadMapStart()
			if yyl981 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl981, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl981 := r.ReadArrayStart()
			if yyl981 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl981, 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 yys982Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys982Slc
	var yyhl982 bool = l >= 0
	for yyj982 := 0; ; yyj982++ {
		if yyhl982 {
			if yyj982 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys982Slc = r.DecodeBytes(yys982Slc, true, true)
		yys982 := string(yys982Slc)
		switch yys982 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg6_util.IntOrString{}
			} else {
				yyv984 := &x.ServicePort
				yym985 := z.DecBinary()
				_ = yym985
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv984) {
				} else if !yym985 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv984)
				} else {
					z.DecFallback(yyv984, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys982)
		} // end switch yys982
	} // end for yyj982
	if !yyhl982 {
		r.ReadEnd()
	}
}

func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj986 int
	var yyb986 bool
	var yyhl986 bool = l >= 0
	yyj986++
	if yyhl986 {
		yyb986 = yyj986 > l
	} else {
		yyb986 = r.CheckBreak()
	}
	if yyb986 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj986++
	if yyhl986 {
		yyb986 = yyj986 > l
	} else {
		yyb986 = r.CheckBreak()
	}
	if yyb986 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg6_util.IntOrString{}
	} else {
		yyv988 := &x.ServicePort
		yym989 := z.DecBinary()
		_ = yym989
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv988) {
		} else if !yym989 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv988)
		} else {
			z.DecFallback(yyv988, false)
		}
	}
	for {
		yyj986++
		if yyhl986 {
			yyb986 = yyj986 > l
		} else {
			yyb986 = r.CheckBreak()
		}
		if yyb986 {
			break
		}
		z.DecStructFieldNotFound(yyj986-1, "")
	}
	r.ReadEnd()
}

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym990 := z.EncBinary()
	_ = yym990
	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
	yym991 := z.DecBinary()
	_ = yym991
	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 {
		yym992 := z.EncBinary()
		_ = yym992
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep993 := !z.EncBinary()
			yy2arr993 := z.EncBasicHandle().StructToArray
			var yyq993 [2]bool
			_, _, _ = yysep993, yyq993, yy2arr993
			const yyr993 bool = false
			if yyr993 || yy2arr993 {
				r.EncodeArrayStart(2)
			} else {
				var yynn993 int = 2
				for _, b := range yyq993 {
					if b {
						yynn993++
					}
				}
				r.EncodeMapStart(yynn993)
			}
			if yyr993 || yy2arr993 {
				x.Resource.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("resource"))
				x.Resource.CodecEncodeSelf(e)
			}
			if yyr993 || yy2arr993 {
				yym996 := z.EncBinary()
				_ = yym996
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				yym997 := z.EncBinary()
				_ = yym997
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yysep993 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *NodeUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym998 := z.DecBinary()
	_ = yym998
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl999 := r.ReadMapStart()
			if yyl999 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl999, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl999 := r.ReadArrayStart()
			if yyl999 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl999, 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 yys1000Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1000Slc
	var yyhl1000 bool = l >= 0
	for yyj1000 := 0; ; yyj1000++ {
		if yyhl1000 {
			if yyj1000 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1000Slc = r.DecodeBytes(yys1000Slc, true, true)
		yys1000 := string(yys1000Slc)
		switch yys1000 {
		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, yys1000)
		} // end switch yys1000
	} // end for yyj1000
	if !yyhl1000 {
		r.ReadEnd()
	}
}

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

func (x *ClusterAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1006 := z.EncBinary()
		_ = yym1006
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1007 := !z.EncBinary()
			yy2arr1007 := z.EncBasicHandle().StructToArray
			var yyq1007 [3]bool
			_, _, _ = yysep1007, yyq1007, yy2arr1007
			const yyr1007 bool = false
			if yyr1007 || yy2arr1007 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1007 int = 3
				for _, b := range yyq1007 {
					if b {
						yynn1007++
					}
				}
				r.EncodeMapStart(yynn1007)
			}
			if yyr1007 || yy2arr1007 {
				yym1009 := z.EncBinary()
				_ = yym1009
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				yym1010 := z.EncBinary()
				_ = yym1010
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1007 || yy2arr1007 {
				yym1012 := z.EncBinary()
				_ = yym1012
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				yym1013 := z.EncBinary()
				_ = yym1013
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1007 || yy2arr1007 {
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1015 := z.EncBinary()
					_ = yym1015
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1016 := z.EncBinary()
					_ = yym1016
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yysep1007 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1017 := z.DecBinary()
	_ = yym1017
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1018 := r.ReadMapStart()
			if yyl1018 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1018, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1018 := r.ReadArrayStart()
			if yyl1018 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1018, 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 yys1019Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1019Slc
	var yyhl1019 bool = l >= 0
	for yyj1019 := 0; ; yyj1019++ {
		if yyhl1019 {
			if yyj1019 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1019Slc = r.DecodeBytes(yys1019Slc, true, true)
		yys1019 := string(yys1019Slc)
		switch yys1019 {
		case "minNodes":
			if r.TryDecodeAsNil() {
				x.MinNodes = 0
			} else {
				x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "maxNodes":
			if r.TryDecodeAsNil() {
				x.MaxNodes = 0
			} else {
				x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "target":
			if r.TryDecodeAsNil() {
				x.TargetUtilization = nil
			} else {
				yyv1022 := &x.TargetUtilization
				yym1023 := z.DecBinary()
				_ = yym1023
				if false {
				} else {
					h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1022), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1019)
		} // end switch yys1019
	} // end for yyj1019
	if !yyhl1019 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1024 int
	var yyb1024 bool
	var yyhl1024 bool = l >= 0
	yyj1024++
	if yyhl1024 {
		yyb1024 = yyj1024 > l
	} else {
		yyb1024 = r.CheckBreak()
	}
	if yyb1024 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1024++
	if yyhl1024 {
		yyb1024 = yyj1024 > l
	} else {
		yyb1024 = r.CheckBreak()
	}
	if yyb1024 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1024++
	if yyhl1024 {
		yyb1024 = yyj1024 > l
	} else {
		yyb1024 = r.CheckBreak()
	}
	if yyb1024 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1027 := &x.TargetUtilization
		yym1028 := z.DecBinary()
		_ = yym1028
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1027), d)
		}
	}
	for {
		yyj1024++
		if yyhl1024 {
			yyb1024 = yyj1024 > l
		} else {
			yyb1024 = r.CheckBreak()
		}
		if yyb1024 {
			break
		}
		z.DecStructFieldNotFound(yyj1024-1, "")
	}
	r.ReadEnd()
}

func (x *ClusterAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1029 := z.EncBinary()
		_ = yym1029
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1030 := !z.EncBinary()
			yy2arr1030 := z.EncBasicHandle().StructToArray
			var yyq1030 [4]bool
			_, _, _ = yysep1030, yyq1030, yy2arr1030
			const yyr1030 bool = false
			yyq1030[0] = x.Kind != ""
			yyq1030[1] = x.APIVersion != ""
			yyq1030[2] = true
			yyq1030[3] = true
			if yyr1030 || yy2arr1030 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1030 int = 0
				for _, b := range yyq1030 {
					if b {
						yynn1030++
					}
				}
				r.EncodeMapStart(yynn1030)
			}
			if yyr1030 || yy2arr1030 {
				if yyq1030[0] {
					yym1032 := z.EncBinary()
					_ = yym1032
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1030[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1033 := z.EncBinary()
					_ = yym1033
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1030 || yy2arr1030 {
				if yyq1030[1] {
					yym1035 := z.EncBinary()
					_ = yym1035
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1030[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1036 := z.EncBinary()
					_ = yym1036
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1030 || yy2arr1030 {
				if yyq1030[2] {
					yy1038 := &x.ObjectMeta
					yy1038.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1030[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1039 := &x.ObjectMeta
					yy1039.CodecEncodeSelf(e)
				}
			}
			if yyr1030 || yy2arr1030 {
				if yyq1030[3] {
					yy1041 := &x.Spec
					yy1041.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1030[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1042 := &x.Spec
					yy1042.CodecEncodeSelf(e)
				}
			}
			if yysep1030 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1043 := z.DecBinary()
	_ = yym1043
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1044 := r.ReadMapStart()
			if yyl1044 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1044, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1044 := r.ReadArrayStart()
			if yyl1044 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1044, 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 yys1045Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1045Slc
	var yyhl1045 bool = l >= 0
	for yyj1045 := 0; ; yyj1045++ {
		if yyhl1045 {
			if yyj1045 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1045Slc = r.DecodeBytes(yys1045Slc, true, true)
		yys1045 := string(yys1045Slc)
		switch yys1045 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv1048 := &x.ObjectMeta
				yyv1048.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ClusterAutoscalerSpec{}
			} else {
				yyv1049 := &x.Spec
				yyv1049.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1045)
		} // end switch yys1045
	} // end for yyj1045
	if !yyhl1045 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1050 int
	var yyb1050 bool
	var yyhl1050 bool = l >= 0
	yyj1050++
	if yyhl1050 {
		yyb1050 = yyj1050 > l
	} else {
		yyb1050 = r.CheckBreak()
	}
	if yyb1050 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1050++
	if yyhl1050 {
		yyb1050 = yyj1050 > l
	} else {
		yyb1050 = r.CheckBreak()
	}
	if yyb1050 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1050++
	if yyhl1050 {
		yyb1050 = yyj1050 > l
	} else {
		yyb1050 = r.CheckBreak()
	}
	if yyb1050 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1053 := &x.ObjectMeta
		yyv1053.CodecDecodeSelf(d)
	}
	yyj1050++
	if yyhl1050 {
		yyb1050 = yyj1050 > l
	} else {
		yyb1050 = r.CheckBreak()
	}
	if yyb1050 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1054 := &x.Spec
		yyv1054.CodecDecodeSelf(d)
	}
	for {
		yyj1050++
		if yyhl1050 {
			yyb1050 = yyj1050 > l
		} else {
			yyb1050 = r.CheckBreak()
		}
		if yyb1050 {
			break
		}
		z.DecStructFieldNotFound(yyj1050-1, "")
	}
	r.ReadEnd()
}

func (x *ClusterAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1055 := z.EncBinary()
		_ = yym1055
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1056 := !z.EncBinary()
			yy2arr1056 := z.EncBasicHandle().StructToArray
			var yyq1056 [4]bool
			_, _, _ = yysep1056, yyq1056, yy2arr1056
			const yyr1056 bool = false
			yyq1056[0] = x.Kind != ""
			yyq1056[1] = x.APIVersion != ""
			yyq1056[2] = true
			if yyr1056 || yy2arr1056 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1056 int = 1
				for _, b := range yyq1056 {
					if b {
						yynn1056++
					}
				}
				r.EncodeMapStart(yynn1056)
			}
			if yyr1056 || yy2arr1056 {
				if yyq1056[0] {
					yym1058 := z.EncBinary()
					_ = yym1058
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1056[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1059 := z.EncBinary()
					_ = yym1059
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1056 || yy2arr1056 {
				if yyq1056[1] {
					yym1061 := z.EncBinary()
					_ = yym1061
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1056[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1062 := z.EncBinary()
					_ = yym1062
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1056 || yy2arr1056 {
				if yyq1056[2] {
					yy1064 := &x.ListMeta
					yym1065 := z.EncBinary()
					_ = yym1065
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1064) {
					} else {
						z.EncFallback(yy1064)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1056[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1066 := &x.ListMeta
					yym1067 := z.EncBinary()
					_ = yym1067
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1066) {
					} else {
						z.EncFallback(yy1066)
					}
				}
			}
			if yyr1056 || yy2arr1056 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1069 := z.EncBinary()
					_ = yym1069
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1070 := z.EncBinary()
					_ = yym1070
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1056 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1071 := z.DecBinary()
	_ = yym1071
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1072 := r.ReadMapStart()
			if yyl1072 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1072, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1072 := r.ReadArrayStart()
			if yyl1072 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1072, 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 yys1073Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1073Slc
	var yyhl1073 bool = l >= 0
	for yyj1073 := 0; ; yyj1073++ {
		if yyhl1073 {
			if yyj1073 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1073Slc = r.DecodeBytes(yys1073Slc, true, true)
		yys1073 := string(yys1073Slc)
		switch yys1073 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv1076 := &x.ListMeta
				yym1077 := z.DecBinary()
				_ = yym1077
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1076) {
				} else {
					z.DecFallback(yyv1076, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1078 := &x.Items
				yym1079 := z.DecBinary()
				_ = yym1079
				if false {
				} else {
					h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1078), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1073)
		} // end switch yys1073
	} // end for yyj1073
	if !yyhl1073 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1080 int
	var yyb1080 bool
	var yyhl1080 bool = l >= 0
	yyj1080++
	if yyhl1080 {
		yyb1080 = yyj1080 > l
	} else {
		yyb1080 = r.CheckBreak()
	}
	if yyb1080 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1080++
	if yyhl1080 {
		yyb1080 = yyj1080 > l
	} else {
		yyb1080 = r.CheckBreak()
	}
	if yyb1080 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1080++
	if yyhl1080 {
		yyb1080 = yyj1080 > l
	} else {
		yyb1080 = r.CheckBreak()
	}
	if yyb1080 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1083 := &x.ListMeta
		yym1084 := z.DecBinary()
		_ = yym1084
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1083) {
		} else {
			z.DecFallback(yyv1083, false)
		}
	}
	yyj1080++
	if yyhl1080 {
		yyb1080 = yyj1080 > l
	} else {
		yyb1080 = r.CheckBreak()
	}
	if yyb1080 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1085 := &x.Items
		yym1086 := z.DecBinary()
		_ = yym1086
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1085), d)
		}
	}
	for {
		yyj1080++
		if yyhl1080 {
			yyb1080 = yyj1080 > l
		} else {
			yyb1080 = r.CheckBreak()
		}
		if yyb1080 {
			break
		}
		z.DecStructFieldNotFound(yyj1080-1, "")
	}
	r.ReadEnd()
}

func (x *PodSelector) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1087 := z.EncBinary()
		_ = yym1087
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1088 := !z.EncBinary()
			yy2arr1088 := z.EncBasicHandle().StructToArray
			var yyq1088 [2]bool
			_, _, _ = yysep1088, yyq1088, yy2arr1088
			const yyr1088 bool = false
			yyq1088[0] = len(x.MatchLabels) != 0
			yyq1088[1] = len(x.MatchExpressions) != 0
			if yyr1088 || yy2arr1088 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1088 int = 0
				for _, b := range yyq1088 {
					if b {
						yynn1088++
					}
				}
				r.EncodeMapStart(yynn1088)
			}
			if yyr1088 || yy2arr1088 {
				if yyq1088[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1090 := z.EncBinary()
						_ = yym1090
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1088[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1091 := z.EncBinary()
						_ = yym1091
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1088 || yy2arr1088 {
				if yyq1088[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1093 := z.EncBinary()
						_ = yym1093
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1088[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1094 := z.EncBinary()
						_ = yym1094
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1088 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *PodSelector) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1095 := z.DecBinary()
	_ = yym1095
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1096 := r.ReadMapStart()
			if yyl1096 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1096, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1096 := r.ReadArrayStart()
			if yyl1096 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1096, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1097Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1097Slc
	var yyhl1097 bool = l >= 0
	for yyj1097 := 0; ; yyj1097++ {
		if yyhl1097 {
			if yyj1097 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1097Slc = r.DecodeBytes(yys1097Slc, true, true)
		yys1097 := string(yys1097Slc)
		switch yys1097 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1098 := &x.MatchLabels
				yym1099 := z.DecBinary()
				_ = yym1099
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1098, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1100 := &x.MatchExpressions
				yym1101 := z.DecBinary()
				_ = yym1101
				if false {
				} else {
					h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1100), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1097)
		} // end switch yys1097
	} // end for yyj1097
	if !yyhl1097 {
		r.ReadEnd()
	}
}

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1102 int
	var yyb1102 bool
	var yyhl1102 bool = l >= 0
	yyj1102++
	if yyhl1102 {
		yyb1102 = yyj1102 > l
	} else {
		yyb1102 = r.CheckBreak()
	}
	if yyb1102 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1103 := &x.MatchLabels
		yym1104 := z.DecBinary()
		_ = yym1104
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1103, false, d)
		}
	}
	yyj1102++
	if yyhl1102 {
		yyb1102 = yyj1102 > l
	} else {
		yyb1102 = r.CheckBreak()
	}
	if yyb1102 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1105 := &x.MatchExpressions
		yym1106 := z.DecBinary()
		_ = yym1106
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1105), d)
		}
	}
	for {
		yyj1102++
		if yyhl1102 {
			yyb1102 = yyj1102 > l
		} else {
			yyb1102 = r.CheckBreak()
		}
		if yyb1102 {
			break
		}
		z.DecStructFieldNotFound(yyj1102-1, "")
	}
	r.ReadEnd()
}

func (x *PodSelectorRequirement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1107 := z.EncBinary()
		_ = yym1107
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1108 := !z.EncBinary()
			yy2arr1108 := z.EncBasicHandle().StructToArray
			var yyq1108 [3]bool
			_, _, _ = yysep1108, yyq1108, yy2arr1108
			const yyr1108 bool = false
			yyq1108[2] = len(x.Values) != 0
			if yyr1108 || yy2arr1108 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1108 int = 2
				for _, b := range yyq1108 {
					if b {
						yynn1108++
					}
				}
				r.EncodeMapStart(yynn1108)
			}
			if yyr1108 || yy2arr1108 {
				yym1110 := z.EncBinary()
				_ = yym1110
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1111 := z.EncBinary()
				_ = yym1111
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1108 || yy2arr1108 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1108 || yy2arr1108 {
				if yyq1108[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1114 := z.EncBinary()
						_ = yym1114
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1108[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1115 := z.EncBinary()
						_ = yym1115
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1108 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *PodSelectorRequirement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1116 := z.DecBinary()
	_ = yym1116
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1117 := r.ReadMapStart()
			if yyl1117 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1117, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1117 := r.ReadArrayStart()
			if yyl1117 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1117, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSelectorRequirement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1118Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1118Slc
	var yyhl1118 bool = l >= 0
	for yyj1118 := 0; ; yyj1118++ {
		if yyhl1118 {
			if yyj1118 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1118Slc = r.DecodeBytes(yys1118Slc, true, true)
		yys1118 := string(yys1118Slc)
		switch yys1118 {
		case "key":
			if r.TryDecodeAsNil() {
				x.Key = ""
			} else {
				x.Key = string(r.DecodeString())
			}
		case "operator":
			if r.TryDecodeAsNil() {
				x.Operator = ""
			} else {
				x.Operator = PodSelectorOperator(r.DecodeString())
			}
		case "values":
			if r.TryDecodeAsNil() {
				x.Values = nil
			} else {
				yyv1121 := &x.Values
				yym1122 := z.DecBinary()
				_ = yym1122
				if false {
				} else {
					z.F.DecSliceStringX(yyv1121, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1118)
		} // end switch yys1118
	} // end for yyj1118
	if !yyhl1118 {
		r.ReadEnd()
	}
}

func (x *PodSelectorRequirement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1123 int
	var yyb1123 bool
	var yyhl1123 bool = l >= 0
	yyj1123++
	if yyhl1123 {
		yyb1123 = yyj1123 > l
	} else {
		yyb1123 = r.CheckBreak()
	}
	if yyb1123 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1123++
	if yyhl1123 {
		yyb1123 = yyj1123 > l
	} else {
		yyb1123 = r.CheckBreak()
	}
	if yyb1123 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = PodSelectorOperator(r.DecodeString())
	}
	yyj1123++
	if yyhl1123 {
		yyb1123 = yyj1123 > l
	} else {
		yyb1123 = r.CheckBreak()
	}
	if yyb1123 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1126 := &x.Values
		yym1127 := z.DecBinary()
		_ = yym1127
		if false {
		} else {
			z.F.DecSliceStringX(yyv1126, false, d)
		}
	}
	for {
		yyj1123++
		if yyhl1123 {
			yyb1123 = yyj1123 > l
		} else {
			yyb1123 = r.CheckBreak()
		}
		if yyb1123 {
			break
		}
		z.DecStructFieldNotFound(yyj1123-1, "")
	}
	r.ReadEnd()
}

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

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

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 _, yyv1130 := range v {
		yy1131 := &yyv1130
		yy1131.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1132 := *v
	yyh1132, yyl1132 := z.DecSliceHelperStart()

	var yyrr1132, yyrl1132 int
	var yyc1132, yyrt1132 bool
	_, _, _ = yyc1132, yyrt1132, yyrl1132
	yyrr1132 = yyl1132

	if yyv1132 == nil {
		if yyrl1132, yyrt1132 = z.DecInferLen(yyl1132, z.DecBasicHandle().MaxInitLen, 336); yyrt1132 {
			yyrr1132 = yyrl1132
		}
		yyv1132 = make([]HorizontalPodAutoscaler, yyrl1132)
		yyc1132 = true
	}

	if yyl1132 == 0 {
		if len(yyv1132) != 0 {
			yyv1132 = yyv1132[:0]
			yyc1132 = true
		}
	} else if yyl1132 > 0 {

		if yyl1132 > cap(yyv1132) {
			yyrl1132, yyrt1132 = z.DecInferLen(yyl1132, z.DecBasicHandle().MaxInitLen, 336)
			yyv1132 = make([]HorizontalPodAutoscaler, yyrl1132)
			yyc1132 = true

			yyrr1132 = len(yyv1132)
		} else if yyl1132 != len(yyv1132) {
			yyv1132 = yyv1132[:yyl1132]
			yyc1132 = true
		}
		yyj1132 := 0
		for ; yyj1132 < yyrr1132; yyj1132++ {
			if r.TryDecodeAsNil() {
				yyv1132[yyj1132] = HorizontalPodAutoscaler{}
			} else {
				yyv1133 := &yyv1132[yyj1132]
				yyv1133.CodecDecodeSelf(d)
			}

		}
		if yyrt1132 {
			for ; yyj1132 < yyl1132; yyj1132++ {
				yyv1132 = append(yyv1132, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1132[yyj1132] = HorizontalPodAutoscaler{}
				} else {
					yyv1134 := &yyv1132[yyj1132]
					yyv1134.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1132 := 0; !r.CheckBreak(); yyj1132++ {
			if yyj1132 >= len(yyv1132) {
				yyv1132 = append(yyv1132, HorizontalPodAutoscaler{}) // var yyz1132 HorizontalPodAutoscaler
				yyc1132 = true
			}

			if yyj1132 < len(yyv1132) {
				if r.TryDecodeAsNil() {
					yyv1132[yyj1132] = HorizontalPodAutoscaler{}
				} else {
					yyv1135 := &yyv1132[yyj1132]
					yyv1135.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1132.End()
	}
	if yyc1132 {
		*v = yyv1132
	}

}

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 _, yyv1136 := range v {
		yy1137 := &yyv1136
		yy1137.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1138 := *v
	yyh1138, yyl1138 := z.DecSliceHelperStart()

	var yyrr1138, yyrl1138 int
	var yyc1138, yyrt1138 bool
	_, _, _ = yyc1138, yyrt1138, yyrl1138
	yyrr1138 = yyl1138

	if yyv1138 == nil {
		if yyrl1138, yyrt1138 = z.DecInferLen(yyl1138, z.DecBasicHandle().MaxInitLen, 32); yyrt1138 {
			yyrr1138 = yyrl1138
		}
		yyv1138 = make([]APIVersion, yyrl1138)
		yyc1138 = true
	}

	if yyl1138 == 0 {
		if len(yyv1138) != 0 {
			yyv1138 = yyv1138[:0]
			yyc1138 = true
		}
	} else if yyl1138 > 0 {

		if yyl1138 > cap(yyv1138) {
			yyrl1138, yyrt1138 = z.DecInferLen(yyl1138, z.DecBasicHandle().MaxInitLen, 32)
			yyv1138 = make([]APIVersion, yyrl1138)
			yyc1138 = true

			yyrr1138 = len(yyv1138)
		} else if yyl1138 != len(yyv1138) {
			yyv1138 = yyv1138[:yyl1138]
			yyc1138 = true
		}
		yyj1138 := 0
		for ; yyj1138 < yyrr1138; yyj1138++ {
			if r.TryDecodeAsNil() {
				yyv1138[yyj1138] = APIVersion{}
			} else {
				yyv1139 := &yyv1138[yyj1138]
				yyv1139.CodecDecodeSelf(d)
			}

		}
		if yyrt1138 {
			for ; yyj1138 < yyl1138; yyj1138++ {
				yyv1138 = append(yyv1138, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1138[yyj1138] = APIVersion{}
				} else {
					yyv1140 := &yyv1138[yyj1138]
					yyv1140.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1138 := 0; !r.CheckBreak(); yyj1138++ {
			if yyj1138 >= len(yyv1138) {
				yyv1138 = append(yyv1138, APIVersion{}) // var yyz1138 APIVersion
				yyc1138 = true
			}

			if yyj1138 < len(yyv1138) {
				if r.TryDecodeAsNil() {
					yyv1138[yyj1138] = APIVersion{}
				} else {
					yyv1141 := &yyv1138[yyj1138]
					yyv1141.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1138.End()
	}
	if yyc1138 {
		*v = yyv1138
	}

}

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 _, yyv1142 := range v {
		yy1143 := &yyv1142
		yy1143.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1144 := *v
	yyh1144, yyl1144 := z.DecSliceHelperStart()

	var yyrr1144, yyrl1144 int
	var yyc1144, yyrt1144 bool
	_, _, _ = yyc1144, yyrt1144, yyrl1144
	yyrr1144 = yyl1144

	if yyv1144 == nil {
		if yyrl1144, yyrt1144 = z.DecInferLen(yyl1144, z.DecBasicHandle().MaxInitLen, 232); yyrt1144 {
			yyrr1144 = yyrl1144
		}
		yyv1144 = make([]ThirdPartyResource, yyrl1144)
		yyc1144 = true
	}

	if yyl1144 == 0 {
		if len(yyv1144) != 0 {
			yyv1144 = yyv1144[:0]
			yyc1144 = true
		}
	} else if yyl1144 > 0 {

		if yyl1144 > cap(yyv1144) {
			yyrl1144, yyrt1144 = z.DecInferLen(yyl1144, z.DecBasicHandle().MaxInitLen, 232)
			yyv1144 = make([]ThirdPartyResource, yyrl1144)
			yyc1144 = true

			yyrr1144 = len(yyv1144)
		} else if yyl1144 != len(yyv1144) {
			yyv1144 = yyv1144[:yyl1144]
			yyc1144 = true
		}
		yyj1144 := 0
		for ; yyj1144 < yyrr1144; yyj1144++ {
			if r.TryDecodeAsNil() {
				yyv1144[yyj1144] = ThirdPartyResource{}
			} else {
				yyv1145 := &yyv1144[yyj1144]
				yyv1145.CodecDecodeSelf(d)
			}

		}
		if yyrt1144 {
			for ; yyj1144 < yyl1144; yyj1144++ {
				yyv1144 = append(yyv1144, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1144[yyj1144] = ThirdPartyResource{}
				} else {
					yyv1146 := &yyv1144[yyj1144]
					yyv1146.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1144 := 0; !r.CheckBreak(); yyj1144++ {
			if yyj1144 >= len(yyv1144) {
				yyv1144 = append(yyv1144, ThirdPartyResource{}) // var yyz1144 ThirdPartyResource
				yyc1144 = true
			}

			if yyj1144 < len(yyv1144) {
				if r.TryDecodeAsNil() {
					yyv1144[yyj1144] = ThirdPartyResource{}
				} else {
					yyv1147 := &yyv1144[yyj1144]
					yyv1147.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1144.End()
	}
	if yyc1144 {
		*v = yyv1144
	}

}

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 _, yyv1148 := range v {
		yy1149 := &yyv1148
		yy1149.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1150 := *v
	yyh1150, yyl1150 := z.DecSliceHelperStart()

	var yyrr1150, yyrl1150 int
	var yyc1150, yyrt1150 bool
	_, _, _ = yyc1150, yyrt1150, yyrl1150
	yyrr1150 = yyl1150

	if yyv1150 == nil {
		if yyrl1150, yyrt1150 = z.DecInferLen(yyl1150, z.DecBasicHandle().MaxInitLen, 592); yyrt1150 {
			yyrr1150 = yyrl1150
		}
		yyv1150 = make([]Deployment, yyrl1150)
		yyc1150 = true
	}

	if yyl1150 == 0 {
		if len(yyv1150) != 0 {
			yyv1150 = yyv1150[:0]
			yyc1150 = true
		}
	} else if yyl1150 > 0 {

		if yyl1150 > cap(yyv1150) {
			yyrl1150, yyrt1150 = z.DecInferLen(yyl1150, z.DecBasicHandle().MaxInitLen, 592)
			yyv1150 = make([]Deployment, yyrl1150)
			yyc1150 = true

			yyrr1150 = len(yyv1150)
		} else if yyl1150 != len(yyv1150) {
			yyv1150 = yyv1150[:yyl1150]
			yyc1150 = true
		}
		yyj1150 := 0
		for ; yyj1150 < yyrr1150; yyj1150++ {
			if r.TryDecodeAsNil() {
				yyv1150[yyj1150] = Deployment{}
			} else {
				yyv1151 := &yyv1150[yyj1150]
				yyv1151.CodecDecodeSelf(d)
			}

		}
		if yyrt1150 {
			for ; yyj1150 < yyl1150; yyj1150++ {
				yyv1150 = append(yyv1150, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1150[yyj1150] = Deployment{}
				} else {
					yyv1152 := &yyv1150[yyj1150]
					yyv1152.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1150 := 0; !r.CheckBreak(); yyj1150++ {
			if yyj1150 >= len(yyv1150) {
				yyv1150 = append(yyv1150, Deployment{}) // var yyz1150 Deployment
				yyc1150 = true
			}

			if yyj1150 < len(yyv1150) {
				if r.TryDecodeAsNil() {
					yyv1150[yyj1150] = Deployment{}
				} else {
					yyv1153 := &yyv1150[yyj1150]
					yyv1153.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1150.End()
	}
	if yyc1150 {
		*v = yyv1150
	}

}

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 _, yyv1154 := range v {
		yy1155 := &yyv1154
		yy1155.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1156 := *v
	yyh1156, yyl1156 := z.DecSliceHelperStart()

	var yyrr1156, yyrl1156 int
	var yyc1156, yyrt1156 bool
	_, _, _ = yyc1156, yyrt1156, yyrl1156
	yyrr1156 = yyl1156

	if yyv1156 == nil {
		if yyrl1156, yyrt1156 = z.DecInferLen(yyl1156, z.DecBasicHandle().MaxInitLen, 232); yyrt1156 {
			yyrr1156 = yyrl1156
		}
		yyv1156 = make([]DaemonSet, yyrl1156)
		yyc1156 = true
	}

	if yyl1156 == 0 {
		if len(yyv1156) != 0 {
			yyv1156 = yyv1156[:0]
			yyc1156 = true
		}
	} else if yyl1156 > 0 {

		if yyl1156 > cap(yyv1156) {
			yyrl1156, yyrt1156 = z.DecInferLen(yyl1156, z.DecBasicHandle().MaxInitLen, 232)
			yyv1156 = make([]DaemonSet, yyrl1156)
			yyc1156 = true

			yyrr1156 = len(yyv1156)
		} else if yyl1156 != len(yyv1156) {
			yyv1156 = yyv1156[:yyl1156]
			yyc1156 = true
		}
		yyj1156 := 0
		for ; yyj1156 < yyrr1156; yyj1156++ {
			if r.TryDecodeAsNil() {
				yyv1156[yyj1156] = DaemonSet{}
			} else {
				yyv1157 := &yyv1156[yyj1156]
				yyv1157.CodecDecodeSelf(d)
			}

		}
		if yyrt1156 {
			for ; yyj1156 < yyl1156; yyj1156++ {
				yyv1156 = append(yyv1156, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1156[yyj1156] = DaemonSet{}
				} else {
					yyv1158 := &yyv1156[yyj1156]
					yyv1158.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1156 := 0; !r.CheckBreak(); yyj1156++ {
			if yyj1156 >= len(yyv1156) {
				yyv1156 = append(yyv1156, DaemonSet{}) // var yyz1156 DaemonSet
				yyc1156 = true
			}

			if yyj1156 < len(yyv1156) {
				if r.TryDecodeAsNil() {
					yyv1156[yyj1156] = DaemonSet{}
				} else {
					yyv1159 := &yyv1156[yyj1156]
					yyv1159.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1156.End()
	}
	if yyc1156 {
		*v = yyv1156
	}

}

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 _, yyv1160 := range v {
		yy1161 := &yyv1160
		yy1161.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1162 := *v
	yyh1162, yyl1162 := z.DecSliceHelperStart()

	var yyrr1162, yyrl1162 int
	var yyc1162, yyrt1162 bool
	_, _, _ = yyc1162, yyrt1162, yyrl1162
	yyrr1162 = yyl1162

	if yyv1162 == nil {
		if yyrl1162, yyrt1162 = z.DecInferLen(yyl1162, z.DecBasicHandle().MaxInitLen, 216); yyrt1162 {
			yyrr1162 = yyrl1162
		}
		yyv1162 = make([]ThirdPartyResourceData, yyrl1162)
		yyc1162 = true
	}

	if yyl1162 == 0 {
		if len(yyv1162) != 0 {
			yyv1162 = yyv1162[:0]
			yyc1162 = true
		}
	} else if yyl1162 > 0 {

		if yyl1162 > cap(yyv1162) {
			yyrl1162, yyrt1162 = z.DecInferLen(yyl1162, z.DecBasicHandle().MaxInitLen, 216)
			yyv1162 = make([]ThirdPartyResourceData, yyrl1162)
			yyc1162 = true

			yyrr1162 = len(yyv1162)
		} else if yyl1162 != len(yyv1162) {
			yyv1162 = yyv1162[:yyl1162]
			yyc1162 = true
		}
		yyj1162 := 0
		for ; yyj1162 < yyrr1162; yyj1162++ {
			if r.TryDecodeAsNil() {
				yyv1162[yyj1162] = ThirdPartyResourceData{}
			} else {
				yyv1163 := &yyv1162[yyj1162]
				yyv1163.CodecDecodeSelf(d)
			}

		}
		if yyrt1162 {
			for ; yyj1162 < yyl1162; yyj1162++ {
				yyv1162 = append(yyv1162, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1162[yyj1162] = ThirdPartyResourceData{}
				} else {
					yyv1164 := &yyv1162[yyj1162]
					yyv1164.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1162 := 0; !r.CheckBreak(); yyj1162++ {
			if yyj1162 >= len(yyv1162) {
				yyv1162 = append(yyv1162, ThirdPartyResourceData{}) // var yyz1162 ThirdPartyResourceData
				yyc1162 = true
			}

			if yyj1162 < len(yyv1162) {
				if r.TryDecodeAsNil() {
					yyv1162[yyj1162] = ThirdPartyResourceData{}
				} else {
					yyv1165 := &yyv1162[yyj1162]
					yyv1165.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1162.End()
	}
	if yyc1162 {
		*v = yyv1162
	}

}

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 _, yyv1166 := range v {
		yy1167 := &yyv1166
		yy1167.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1168 := *v
	yyh1168, yyl1168 := z.DecSliceHelperStart()

	var yyrr1168, yyrl1168 int
	var yyc1168, yyrt1168 bool
	_, _, _ = yyc1168, yyrt1168, yyrl1168
	yyrr1168 = yyl1168

	if yyv1168 == nil {
		if yyrl1168, yyrt1168 = z.DecInferLen(yyl1168, z.DecBasicHandle().MaxInitLen, 608); yyrt1168 {
			yyrr1168 = yyrl1168
		}
		yyv1168 = make([]Job, yyrl1168)
		yyc1168 = true
	}

	if yyl1168 == 0 {
		if len(yyv1168) != 0 {
			yyv1168 = yyv1168[:0]
			yyc1168 = true
		}
	} else if yyl1168 > 0 {

		if yyl1168 > cap(yyv1168) {
			yyrl1168, yyrt1168 = z.DecInferLen(yyl1168, z.DecBasicHandle().MaxInitLen, 608)
			yyv1168 = make([]Job, yyrl1168)
			yyc1168 = true

			yyrr1168 = len(yyv1168)
		} else if yyl1168 != len(yyv1168) {
			yyv1168 = yyv1168[:yyl1168]
			yyc1168 = true
		}
		yyj1168 := 0
		for ; yyj1168 < yyrr1168; yyj1168++ {
			if r.TryDecodeAsNil() {
				yyv1168[yyj1168] = Job{}
			} else {
				yyv1169 := &yyv1168[yyj1168]
				yyv1169.CodecDecodeSelf(d)
			}

		}
		if yyrt1168 {
			for ; yyj1168 < yyl1168; yyj1168++ {
				yyv1168 = append(yyv1168, Job{})
				if r.TryDecodeAsNil() {
					yyv1168[yyj1168] = Job{}
				} else {
					yyv1170 := &yyv1168[yyj1168]
					yyv1170.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1168 := 0; !r.CheckBreak(); yyj1168++ {
			if yyj1168 >= len(yyv1168) {
				yyv1168 = append(yyv1168, Job{}) // var yyz1168 Job
				yyc1168 = true
			}

			if yyj1168 < len(yyv1168) {
				if r.TryDecodeAsNil() {
					yyv1168[yyj1168] = Job{}
				} else {
					yyv1171 := &yyv1168[yyj1168]
					yyv1171.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1168.End()
	}
	if yyc1168 {
		*v = yyv1168
	}

}

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 _, yyv1172 := range v {
		yy1173 := &yyv1172
		yy1173.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1174 := *v
	yyh1174, yyl1174 := z.DecSliceHelperStart()

	var yyrr1174, yyrl1174 int
	var yyc1174, yyrt1174 bool
	_, _, _ = yyc1174, yyrt1174, yyrl1174
	yyrr1174 = yyl1174

	if yyv1174 == nil {
		if yyrl1174, yyrt1174 = z.DecInferLen(yyl1174, z.DecBasicHandle().MaxInitLen, 112); yyrt1174 {
			yyrr1174 = yyrl1174
		}
		yyv1174 = make([]JobCondition, yyrl1174)
		yyc1174 = true
	}

	if yyl1174 == 0 {
		if len(yyv1174) != 0 {
			yyv1174 = yyv1174[:0]
			yyc1174 = true
		}
	} else if yyl1174 > 0 {

		if yyl1174 > cap(yyv1174) {
			yyrl1174, yyrt1174 = z.DecInferLen(yyl1174, z.DecBasicHandle().MaxInitLen, 112)
			yyv1174 = make([]JobCondition, yyrl1174)
			yyc1174 = true

			yyrr1174 = len(yyv1174)
		} else if yyl1174 != len(yyv1174) {
			yyv1174 = yyv1174[:yyl1174]
			yyc1174 = true
		}
		yyj1174 := 0
		for ; yyj1174 < yyrr1174; yyj1174++ {
			if r.TryDecodeAsNil() {
				yyv1174[yyj1174] = JobCondition{}
			} else {
				yyv1175 := &yyv1174[yyj1174]
				yyv1175.CodecDecodeSelf(d)
			}

		}
		if yyrt1174 {
			for ; yyj1174 < yyl1174; yyj1174++ {
				yyv1174 = append(yyv1174, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1174[yyj1174] = JobCondition{}
				} else {
					yyv1176 := &yyv1174[yyj1174]
					yyv1176.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1174 := 0; !r.CheckBreak(); yyj1174++ {
			if yyj1174 >= len(yyv1174) {
				yyv1174 = append(yyv1174, JobCondition{}) // var yyz1174 JobCondition
				yyc1174 = true
			}

			if yyj1174 < len(yyv1174) {
				if r.TryDecodeAsNil() {
					yyv1174[yyj1174] = JobCondition{}
				} else {
					yyv1177 := &yyv1174[yyj1174]
					yyv1177.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1174.End()
	}
	if yyc1174 {
		*v = yyv1174
	}

}

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 _, yyv1178 := range v {
		yy1179 := &yyv1178
		yy1179.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1180 := *v
	yyh1180, yyl1180 := z.DecSliceHelperStart()

	var yyrr1180, yyrl1180 int
	var yyc1180, yyrt1180 bool
	_, _, _ = yyc1180, yyrt1180, yyrl1180
	yyrr1180 = yyl1180

	if yyv1180 == nil {
		if yyrl1180, yyrt1180 = z.DecInferLen(yyl1180, z.DecBasicHandle().MaxInitLen, 248); yyrt1180 {
			yyrr1180 = yyrl1180
		}
		yyv1180 = make([]Ingress, yyrl1180)
		yyc1180 = true
	}

	if yyl1180 == 0 {
		if len(yyv1180) != 0 {
			yyv1180 = yyv1180[:0]
			yyc1180 = true
		}
	} else if yyl1180 > 0 {

		if yyl1180 > cap(yyv1180) {
			yyrl1180, yyrt1180 = z.DecInferLen(yyl1180, z.DecBasicHandle().MaxInitLen, 248)
			yyv1180 = make([]Ingress, yyrl1180)
			yyc1180 = true

			yyrr1180 = len(yyv1180)
		} else if yyl1180 != len(yyv1180) {
			yyv1180 = yyv1180[:yyl1180]
			yyc1180 = true
		}
		yyj1180 := 0
		for ; yyj1180 < yyrr1180; yyj1180++ {
			if r.TryDecodeAsNil() {
				yyv1180[yyj1180] = Ingress{}
			} else {
				yyv1181 := &yyv1180[yyj1180]
				yyv1181.CodecDecodeSelf(d)
			}

		}
		if yyrt1180 {
			for ; yyj1180 < yyl1180; yyj1180++ {
				yyv1180 = append(yyv1180, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1180[yyj1180] = Ingress{}
				} else {
					yyv1182 := &yyv1180[yyj1180]
					yyv1182.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1180 := 0; !r.CheckBreak(); yyj1180++ {
			if yyj1180 >= len(yyv1180) {
				yyv1180 = append(yyv1180, Ingress{}) // var yyz1180 Ingress
				yyc1180 = true
			}

			if yyj1180 < len(yyv1180) {
				if r.TryDecodeAsNil() {
					yyv1180[yyj1180] = Ingress{}
				} else {
					yyv1183 := &yyv1180[yyj1180]
					yyv1183.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1180.End()
	}
	if yyc1180 {
		*v = yyv1180
	}

}

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 _, yyv1184 := range v {
		yy1185 := &yyv1184
		yy1185.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1186 := *v
	yyh1186, yyl1186 := z.DecSliceHelperStart()

	var yyrr1186, yyrl1186 int
	var yyc1186, yyrt1186 bool
	_, _, _ = yyc1186, yyrt1186, yyrl1186
	yyrr1186 = yyl1186

	if yyv1186 == nil {
		if yyrl1186, yyrt1186 = z.DecInferLen(yyl1186, z.DecBasicHandle().MaxInitLen, 24); yyrt1186 {
			yyrr1186 = yyrl1186
		}
		yyv1186 = make([]IngressRule, yyrl1186)
		yyc1186 = true
	}

	if yyl1186 == 0 {
		if len(yyv1186) != 0 {
			yyv1186 = yyv1186[:0]
			yyc1186 = true
		}
	} else if yyl1186 > 0 {

		if yyl1186 > cap(yyv1186) {
			yyrl1186, yyrt1186 = z.DecInferLen(yyl1186, z.DecBasicHandle().MaxInitLen, 24)
			yyv1186 = make([]IngressRule, yyrl1186)
			yyc1186 = true

			yyrr1186 = len(yyv1186)
		} else if yyl1186 != len(yyv1186) {
			yyv1186 = yyv1186[:yyl1186]
			yyc1186 = true
		}
		yyj1186 := 0
		for ; yyj1186 < yyrr1186; yyj1186++ {
			if r.TryDecodeAsNil() {
				yyv1186[yyj1186] = IngressRule{}
			} else {
				yyv1187 := &yyv1186[yyj1186]
				yyv1187.CodecDecodeSelf(d)
			}

		}
		if yyrt1186 {
			for ; yyj1186 < yyl1186; yyj1186++ {
				yyv1186 = append(yyv1186, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1186[yyj1186] = IngressRule{}
				} else {
					yyv1188 := &yyv1186[yyj1186]
					yyv1188.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1186 := 0; !r.CheckBreak(); yyj1186++ {
			if yyj1186 >= len(yyv1186) {
				yyv1186 = append(yyv1186, IngressRule{}) // var yyz1186 IngressRule
				yyc1186 = true
			}

			if yyj1186 < len(yyv1186) {
				if r.TryDecodeAsNil() {
					yyv1186[yyj1186] = IngressRule{}
				} else {
					yyv1189 := &yyv1186[yyj1186]
					yyv1189.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1186.End()
	}
	if yyc1186 {
		*v = yyv1186
	}

}

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 _, yyv1190 := range v {
		yy1191 := &yyv1190
		yy1191.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1192 := *v
	yyh1192, yyl1192 := z.DecSliceHelperStart()

	var yyrr1192, yyrl1192 int
	var yyc1192, yyrt1192 bool
	_, _, _ = yyc1192, yyrt1192, yyrl1192
	yyrr1192 = yyl1192

	if yyv1192 == nil {
		if yyrl1192, yyrt1192 = z.DecInferLen(yyl1192, z.DecBasicHandle().MaxInitLen, 64); yyrt1192 {
			yyrr1192 = yyrl1192
		}
		yyv1192 = make([]HTTPIngressPath, yyrl1192)
		yyc1192 = true
	}

	if yyl1192 == 0 {
		if len(yyv1192) != 0 {
			yyv1192 = yyv1192[:0]
			yyc1192 = true
		}
	} else if yyl1192 > 0 {

		if yyl1192 > cap(yyv1192) {
			yyrl1192, yyrt1192 = z.DecInferLen(yyl1192, z.DecBasicHandle().MaxInitLen, 64)
			yyv1192 = make([]HTTPIngressPath, yyrl1192)
			yyc1192 = true

			yyrr1192 = len(yyv1192)
		} else if yyl1192 != len(yyv1192) {
			yyv1192 = yyv1192[:yyl1192]
			yyc1192 = true
		}
		yyj1192 := 0
		for ; yyj1192 < yyrr1192; yyj1192++ {
			if r.TryDecodeAsNil() {
				yyv1192[yyj1192] = HTTPIngressPath{}
			} else {
				yyv1193 := &yyv1192[yyj1192]
				yyv1193.CodecDecodeSelf(d)
			}

		}
		if yyrt1192 {
			for ; yyj1192 < yyl1192; yyj1192++ {
				yyv1192 = append(yyv1192, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1192[yyj1192] = HTTPIngressPath{}
				} else {
					yyv1194 := &yyv1192[yyj1192]
					yyv1194.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1192 := 0; !r.CheckBreak(); yyj1192++ {
			if yyj1192 >= len(yyv1192) {
				yyv1192 = append(yyv1192, HTTPIngressPath{}) // var yyz1192 HTTPIngressPath
				yyc1192 = true
			}

			if yyj1192 < len(yyv1192) {
				if r.TryDecodeAsNil() {
					yyv1192[yyj1192] = HTTPIngressPath{}
				} else {
					yyv1195 := &yyv1192[yyj1192]
					yyv1195.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1192.End()
	}
	if yyc1192 {
		*v = yyv1192
	}

}

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 _, yyv1196 := range v {
		yy1197 := &yyv1196
		yy1197.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1198 := *v
	yyh1198, yyl1198 := z.DecSliceHelperStart()

	var yyrr1198, yyrl1198 int
	var yyc1198, yyrt1198 bool
	_, _, _ = yyc1198, yyrt1198, yyrl1198
	yyrr1198 = yyl1198

	if yyv1198 == nil {
		if yyrl1198, yyrt1198 = z.DecInferLen(yyl1198, z.DecBasicHandle().MaxInitLen, 24); yyrt1198 {
			yyrr1198 = yyrl1198
		}
		yyv1198 = make([]NodeUtilization, yyrl1198)
		yyc1198 = true
	}

	if yyl1198 == 0 {
		if len(yyv1198) != 0 {
			yyv1198 = yyv1198[:0]
			yyc1198 = true
		}
	} else if yyl1198 > 0 {

		if yyl1198 > cap(yyv1198) {
			yyrl1198, yyrt1198 = z.DecInferLen(yyl1198, z.DecBasicHandle().MaxInitLen, 24)
			yyv1198 = make([]NodeUtilization, yyrl1198)
			yyc1198 = true

			yyrr1198 = len(yyv1198)
		} else if yyl1198 != len(yyv1198) {
			yyv1198 = yyv1198[:yyl1198]
			yyc1198 = true
		}
		yyj1198 := 0
		for ; yyj1198 < yyrr1198; yyj1198++ {
			if r.TryDecodeAsNil() {
				yyv1198[yyj1198] = NodeUtilization{}
			} else {
				yyv1199 := &yyv1198[yyj1198]
				yyv1199.CodecDecodeSelf(d)
			}

		}
		if yyrt1198 {
			for ; yyj1198 < yyl1198; yyj1198++ {
				yyv1198 = append(yyv1198, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1198[yyj1198] = NodeUtilization{}
				} else {
					yyv1200 := &yyv1198[yyj1198]
					yyv1200.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1198 := 0; !r.CheckBreak(); yyj1198++ {
			if yyj1198 >= len(yyv1198) {
				yyv1198 = append(yyv1198, NodeUtilization{}) // var yyz1198 NodeUtilization
				yyc1198 = true
			}

			if yyj1198 < len(yyv1198) {
				if r.TryDecodeAsNil() {
					yyv1198[yyj1198] = NodeUtilization{}
				} else {
					yyv1201 := &yyv1198[yyj1198]
					yyv1201.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1198.End()
	}
	if yyc1198 {
		*v = yyv1198
	}

}

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 _, yyv1202 := range v {
		yy1203 := &yyv1202
		yy1203.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1204 := *v
	yyh1204, yyl1204 := z.DecSliceHelperStart()

	var yyrr1204, yyrl1204 int
	var yyc1204, yyrt1204 bool
	_, _, _ = yyc1204, yyrt1204, yyrl1204
	yyrr1204 = yyl1204

	if yyv1204 == nil {
		if yyrl1204, yyrt1204 = z.DecInferLen(yyl1204, z.DecBasicHandle().MaxInitLen, 232); yyrt1204 {
			yyrr1204 = yyrl1204
		}
		yyv1204 = make([]ClusterAutoscaler, yyrl1204)
		yyc1204 = true
	}

	if yyl1204 == 0 {
		if len(yyv1204) != 0 {
			yyv1204 = yyv1204[:0]
			yyc1204 = true
		}
	} else if yyl1204 > 0 {

		if yyl1204 > cap(yyv1204) {
			yyrl1204, yyrt1204 = z.DecInferLen(yyl1204, z.DecBasicHandle().MaxInitLen, 232)
			yyv1204 = make([]ClusterAutoscaler, yyrl1204)
			yyc1204 = true

			yyrr1204 = len(yyv1204)
		} else if yyl1204 != len(yyv1204) {
			yyv1204 = yyv1204[:yyl1204]
			yyc1204 = true
		}
		yyj1204 := 0
		for ; yyj1204 < yyrr1204; yyj1204++ {
			if r.TryDecodeAsNil() {
				yyv1204[yyj1204] = ClusterAutoscaler{}
			} else {
				yyv1205 := &yyv1204[yyj1204]
				yyv1205.CodecDecodeSelf(d)
			}

		}
		if yyrt1204 {
			for ; yyj1204 < yyl1204; yyj1204++ {
				yyv1204 = append(yyv1204, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1204[yyj1204] = ClusterAutoscaler{}
				} else {
					yyv1206 := &yyv1204[yyj1204]
					yyv1206.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1204 := 0; !r.CheckBreak(); yyj1204++ {
			if yyj1204 >= len(yyv1204) {
				yyv1204 = append(yyv1204, ClusterAutoscaler{}) // var yyz1204 ClusterAutoscaler
				yyc1204 = true
			}

			if yyj1204 < len(yyv1204) {
				if r.TryDecodeAsNil() {
					yyv1204[yyj1204] = ClusterAutoscaler{}
				} else {
					yyv1207 := &yyv1204[yyj1204]
					yyv1207.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1204.End()
	}
	if yyc1204 {
		*v = yyv1204
	}

}

func (x codecSelfer1234) encSlicePodSelectorRequirement(v []PodSelectorRequirement, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1208 := range v {
		yy1209 := &yyv1208
		yy1209.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1210 := *v
	yyh1210, yyl1210 := z.DecSliceHelperStart()

	var yyrr1210, yyrl1210 int
	var yyc1210, yyrt1210 bool
	_, _, _ = yyc1210, yyrt1210, yyrl1210
	yyrr1210 = yyl1210

	if yyv1210 == nil {
		if yyrl1210, yyrt1210 = z.DecInferLen(yyl1210, z.DecBasicHandle().MaxInitLen, 56); yyrt1210 {
			yyrr1210 = yyrl1210
		}
		yyv1210 = make([]PodSelectorRequirement, yyrl1210)
		yyc1210 = true
	}

	if yyl1210 == 0 {
		if len(yyv1210) != 0 {
			yyv1210 = yyv1210[:0]
			yyc1210 = true
		}
	} else if yyl1210 > 0 {

		if yyl1210 > cap(yyv1210) {
			yyrl1210, yyrt1210 = z.DecInferLen(yyl1210, z.DecBasicHandle().MaxInitLen, 56)
			yyv1210 = make([]PodSelectorRequirement, yyrl1210)
			yyc1210 = true

			yyrr1210 = len(yyv1210)
		} else if yyl1210 != len(yyv1210) {
			yyv1210 = yyv1210[:yyl1210]
			yyc1210 = true
		}
		yyj1210 := 0
		for ; yyj1210 < yyrr1210; yyj1210++ {
			if r.TryDecodeAsNil() {
				yyv1210[yyj1210] = PodSelectorRequirement{}
			} else {
				yyv1211 := &yyv1210[yyj1210]
				yyv1211.CodecDecodeSelf(d)
			}

		}
		if yyrt1210 {
			for ; yyj1210 < yyl1210; yyj1210++ {
				yyv1210 = append(yyv1210, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1210[yyj1210] = PodSelectorRequirement{}
				} else {
					yyv1212 := &yyv1210[yyj1210]
					yyv1212.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1210 := 0; !r.CheckBreak(); yyj1210++ {
			if yyj1210 >= len(yyv1210) {
				yyv1210 = append(yyv1210, PodSelectorRequirement{}) // var yyz1210 PodSelectorRequirement
				yyc1210 = true
			}

			if yyj1210 < len(yyv1210) {
				if r.TryDecodeAsNil() {
					yyv1210[yyj1210] = PodSelectorRequirement{}
				} else {
					yyv1213 := &yyv1210[yyj1210]
					yyv1213.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1210.End()
	}
	if yyc1210 {
		*v = yyv1210
	}

}