types.generated.go

/*
Copyright 2015 The Kubernetes Authors All rights reserved.

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

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

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

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

package v1beta1

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	pkg6_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 pkg4_resource.Quantity
		var v1 pkg1_unversioned.TypeMeta
		var v2 pkg2_v1.ObjectMeta
		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_v1.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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_v1.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 != nil
			yyq392[1] = len(x.Selector) != 0
			yyq392[2] = x.Template != nil
			yyq392[3] = true
			yyq392[4] = x.UniqueLabelKey != nil
			if yyr392 || yy2arr392 {
				r.EncodeArrayStart(5)
			} else {
				var yynn392 int = 0
				for _, b := range yyq392 {
					if b {
						yynn392++
					}
				}
				r.EncodeMapStart(yynn392)
			}
			if yyr392 || yy2arr392 {
				if yyq392[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy394 := *x.Replicas
						yym395 := z.EncBinary()
						_ = yym395
						if false {
						} else {
							r.EncodeInt(int64(yy394))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy396 := *x.Replicas
						yym397 := z.EncBinary()
						_ = yym397
						if false {
						} else {
							r.EncodeInt(int64(yy396))
						}
					}
				}
			}
			if yyr392 || yy2arr392 {
				if yyq392[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym399 := z.EncBinary()
						_ = yym399
						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 {
						yym400 := z.EncBinary()
						_ = yym400
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr392 || yy2arr392 {
				if yyq392[2] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[2] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.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] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy406 := *x.UniqueLabelKey
						yym407 := z.EncBinary()
						_ = yym407
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy406))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[4] {
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy408 := *x.UniqueLabelKey
						yym409 := z.EncBinary()
						_ = yym409
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy408))
						}
					}
				}
			}
			if yysep392 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj421 int
	var yyb421 bool
	var yyhl421 bool = l >= 0
	yyj421++
	if yyhl421 {
		yyb421 = yyj421 > l
	} else {
		yyb421 = r.CheckBreak()
	}
	if yyb421 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int)
		}
		yym423 := z.DecBinary()
		_ = yym423
		if false {
		} else {
			*((*int)(x.Replicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj421++
	if yyhl421 {
		yyb421 = yyj421 > l
	} else {
		yyb421 = r.CheckBreak()
	}
	if yyb421 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv424 := &x.Selector
		yym425 := z.DecBinary()
		_ = yym425
		if false {
		} else {
			z.F.DecMapStringStringX(yyv424, false, d)
		}
	}
	yyj421++
	if yyhl421 {
		yyb421 = yyj421 > l
	} else {
		yyb421 = r.CheckBreak()
	}
	if yyb421 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_v1.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	yyj421++
	if yyhl421 {
		yyb421 = yyj421 > l
	} else {
		yyb421 = r.CheckBreak()
	}
	if yyb421 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv427 := &x.Strategy
		yyv427.CodecDecodeSelf(d)
	}
	yyj421++
	if yyhl421 {
		yyb421 = yyj421 > l
	} else {
		yyb421 = r.CheckBreak()
	}
	if yyb421 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym429 := z.DecBinary()
		_ = yym429
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj421++
		if yyhl421 {
			yyb421 = yyj421 > l
		} else {
			yyb421 = r.CheckBreak()
		}
		if yyb421 {
			break
		}
		z.DecStructFieldNotFound(yyj421-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 {
		yym430 := z.EncBinary()
		_ = yym430
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep431 := !z.EncBinary()
			yy2arr431 := z.EncBasicHandle().StructToArray
			var yyq431 [2]bool
			_, _, _ = yysep431, yyq431, yy2arr431
			const yyr431 bool = false
			yyq431[0] = x.Type != ""
			yyq431[1] = x.RollingUpdate != nil
			if yyr431 || yy2arr431 {
				r.EncodeArrayStart(2)
			} else {
				var yynn431 int = 0
				for _, b := range yyq431 {
					if b {
						yynn431++
					}
				}
				r.EncodeMapStart(yynn431)
			}
			if yyr431 || yy2arr431 {
				if yyq431[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq431[0] {
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr431 || yy2arr431 {
				if yyq431[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq431[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yysep431 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj439 int
	var yyb439 bool
	var yyhl439 bool = l >= 0
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj439++
	if yyhl439 {
		yyb439 = yyj439 > l
	} else {
		yyb439 = r.CheckBreak()
	}
	if yyb439 {
		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 {
		yyj439++
		if yyhl439 {
			yyb439 = yyj439 > l
		} else {
			yyb439 = r.CheckBreak()
		}
		if yyb439 {
			break
		}
		z.DecStructFieldNotFound(yyj439-1, "")
	}
	r.ReadEnd()
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym442 := z.EncBinary()
	_ = yym442
	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
	yym443 := z.DecBinary()
	_ = yym443
	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 {
		yym444 := z.EncBinary()
		_ = yym444
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep445 := !z.EncBinary()
			yy2arr445 := z.EncBasicHandle().StructToArray
			var yyq445 [3]bool
			_, _, _ = yysep445, yyq445, yy2arr445
			const yyr445 bool = false
			yyq445[0] = x.MaxUnavailable != nil
			yyq445[1] = x.MaxSurge != nil
			yyq445[2] = x.MinReadySeconds != 0
			if yyr445 || yy2arr445 {
				r.EncodeArrayStart(3)
			} else {
				var yynn445 int = 0
				for _, b := range yyq445 {
					if b {
						yynn445++
					}
				}
				r.EncodeMapStart(yynn445)
			}
			if yyr445 || yy2arr445 {
				if yyq445[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym447 := z.EncBinary()
						_ = yym447
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym447 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq445[0] {
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym448 := z.EncBinary()
						_ = yym448
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym448 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr445 || yy2arr445 {
				if yyq445[1] {
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym450 := z.EncBinary()
						_ = yym450
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym450 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq445[1] {
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym451 := z.EncBinary()
						_ = yym451
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym451 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				}
			}
			if yyr445 || yy2arr445 {
				if yyq445[2] {
					yym453 := z.EncBinary()
					_ = yym453
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq445[2] {
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					yym454 := z.EncBinary()
					_ = yym454
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yysep445 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj463 int
	var yyb463 bool
	var yyhl463 bool = l >= 0
	yyj463++
	if yyhl463 {
		yyb463 = yyj463 > l
	} else {
		yyb463 = r.CheckBreak()
	}
	if yyb463 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_util.IntOrString)
		}
		yym465 := z.DecBinary()
		_ = yym465
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym465 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj463++
	if yyhl463 {
		yyb463 = yyj463 > l
	} else {
		yyb463 = r.CheckBreak()
	}
	if yyb463 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg6_util.IntOrString)
		}
		yym467 := z.DecBinary()
		_ = yym467
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym467 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	yyj463++
	if yyhl463 {
		yyb463 = yyj463 > l
	} else {
		yyb463 = r.CheckBreak()
	}
	if yyb463 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj463++
		if yyhl463 {
			yyb463 = yyj463 > l
		} else {
			yyb463 = r.CheckBreak()
		}
		if yyb463 {
			break
		}
		z.DecStructFieldNotFound(yyj463-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 {
		yym469 := z.EncBinary()
		_ = yym469
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep470 := !z.EncBinary()
			yy2arr470 := z.EncBasicHandle().StructToArray
			var yyq470 [2]bool
			_, _, _ = yysep470, yyq470, yy2arr470
			const yyr470 bool = false
			yyq470[0] = x.Replicas != 0
			yyq470[1] = x.UpdatedReplicas != 0
			if yyr470 || yy2arr470 {
				r.EncodeArrayStart(2)
			} else {
				var yynn470 int = 0
				for _, b := range yyq470 {
					if b {
						yynn470++
					}
				}
				r.EncodeMapStart(yynn470)
			}
			if yyr470 || yy2arr470 {
				if yyq470[0] {
					yym472 := z.EncBinary()
					_ = yym472
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq470[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym473 := z.EncBinary()
					_ = yym473
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr470 || yy2arr470 {
				if yyq470[1] {
					yym475 := z.EncBinary()
					_ = yym475
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq470[1] {
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					yym476 := z.EncBinary()
					_ = yym476
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yysep470 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj482 int
	var yyb482 bool
	var yyhl482 bool = l >= 0
	yyj482++
	if yyhl482 {
		yyb482 = yyj482 > l
	} else {
		yyb482 = r.CheckBreak()
	}
	if yyb482 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj482++
	if yyhl482 {
		yyb482 = yyj482 > l
	} else {
		yyb482 = r.CheckBreak()
	}
	if yyb482 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj482++
		if yyhl482 {
			yyb482 = yyj482 > l
		} else {
			yyb482 = r.CheckBreak()
		}
		if yyb482 {
			break
		}
		z.DecStructFieldNotFound(yyj482-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 {
		yym485 := z.EncBinary()
		_ = yym485
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep486 := !z.EncBinary()
			yy2arr486 := z.EncBasicHandle().StructToArray
			var yyq486 [4]bool
			_, _, _ = yysep486, yyq486, yy2arr486
			const yyr486 bool = false
			yyq486[0] = x.Kind != ""
			yyq486[1] = x.APIVersion != ""
			yyq486[2] = true
			if yyr486 || yy2arr486 {
				r.EncodeArrayStart(4)
			} else {
				var yynn486 int = 1
				for _, b := range yyq486 {
					if b {
						yynn486++
					}
				}
				r.EncodeMapStart(yynn486)
			}
			if yyr486 || yy2arr486 {
				if yyq486[0] {
					yym488 := z.EncBinary()
					_ = yym488
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq486[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym489 := z.EncBinary()
					_ = yym489
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr486 || yy2arr486 {
				if yyq486[1] {
					yym491 := z.EncBinary()
					_ = yym491
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq486[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym492 := z.EncBinary()
					_ = yym492
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr486 || yy2arr486 {
				if yyq486[2] {
					yy494 := &x.ListMeta
					yym495 := z.EncBinary()
					_ = yym495
					if false {
					} else if z.HasExtensions() && z.EncExt(yy494) {
					} else {
						z.EncFallback(yy494)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq486[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy496 := &x.ListMeta
					yym497 := z.EncBinary()
					_ = yym497
					if false {
					} else if z.HasExtensions() && z.EncExt(yy496) {
					} else {
						z.EncFallback(yy496)
					}
				}
			}
			if yyr486 || yy2arr486 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym499 := z.EncBinary()
					_ = yym499
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym500 := z.EncBinary()
					_ = yym500
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yysep486 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym501 := z.DecBinary()
	_ = yym501
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl502 := r.ReadMapStart()
			if yyl502 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl502, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl502 := r.ReadArrayStart()
			if yyl502 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl502, 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 yys503Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys503Slc
	var yyhl503 bool = l >= 0
	for yyj503 := 0; ; yyj503++ {
		if yyhl503 {
			if yyj503 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys503Slc = r.DecodeBytes(yys503Slc, true, true)
		yys503 := string(yys503Slc)
		switch yys503 {
		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 {
				yyv506 := &x.ListMeta
				yym507 := z.DecBinary()
				_ = yym507
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv506) {
				} else {
					z.DecFallback(yyv506, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv508 := &x.Items
				yym509 := z.DecBinary()
				_ = yym509
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv508), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys503)
		} // end switch yys503
	} // end for yyj503
	if !yyhl503 {
		r.ReadEnd()
	}
}

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj510 int
	var yyb510 bool
	var yyhl510 bool = l >= 0
	yyj510++
	if yyhl510 {
		yyb510 = yyj510 > l
	} else {
		yyb510 = r.CheckBreak()
	}
	if yyb510 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj510++
	if yyhl510 {
		yyb510 = yyj510 > l
	} else {
		yyb510 = r.CheckBreak()
	}
	if yyb510 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj510++
	if yyhl510 {
		yyb510 = yyj510 > l
	} else {
		yyb510 = r.CheckBreak()
	}
	if yyb510 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv513 := &x.ListMeta
		yym514 := z.DecBinary()
		_ = yym514
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv513) {
		} else {
			z.DecFallback(yyv513, false)
		}
	}
	yyj510++
	if yyhl510 {
		yyb510 = yyj510 > l
	} else {
		yyb510 = r.CheckBreak()
	}
	if yyb510 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv515 := &x.Items
		yym516 := z.DecBinary()
		_ = yym516
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv515), d)
		}
	}
	for {
		yyj510++
		if yyhl510 {
			yyb510 = yyj510 > l
		} else {
			yyb510 = r.CheckBreak()
		}
		if yyb510 {
			break
		}
		z.DecStructFieldNotFound(yyj510-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 {
		yym517 := z.EncBinary()
		_ = yym517
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep518 := !z.EncBinary()
			yy2arr518 := z.EncBasicHandle().StructToArray
			var yyq518 [2]bool
			_, _, _ = yysep518, yyq518, yy2arr518
			const yyr518 bool = false
			yyq518[0] = len(x.Selector) != 0
			yyq518[1] = x.Template != nil
			if yyr518 || yy2arr518 {
				r.EncodeArrayStart(2)
			} else {
				var yynn518 int = 0
				for _, b := range yyq518 {
					if b {
						yynn518++
					}
				}
				r.EncodeMapStart(yynn518)
			}
			if yyr518 || yy2arr518 {
				if yyq518[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym520 := z.EncBinary()
						_ = yym520
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq518[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym521 := z.EncBinary()
						_ = yym521
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr518 || yy2arr518 {
				if yyq518[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq518[1] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yysep518 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj529 int
	var yyb529 bool
	var yyhl529 bool = l >= 0
	yyj529++
	if yyhl529 {
		yyb529 = yyj529 > l
	} else {
		yyb529 = r.CheckBreak()
	}
	if yyb529 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv530 := &x.Selector
		yym531 := z.DecBinary()
		_ = yym531
		if false {
		} else {
			z.F.DecMapStringStringX(yyv530, false, d)
		}
	}
	yyj529++
	if yyhl529 {
		yyb529 = yyj529 > l
	} else {
		yyb529 = r.CheckBreak()
	}
	if yyb529 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_v1.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj529++
		if yyhl529 {
			yyb529 = yyj529 > l
		} else {
			yyb529 = r.CheckBreak()
		}
		if yyb529 {
			break
		}
		z.DecStructFieldNotFound(yyj529-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 {
		yym533 := z.EncBinary()
		_ = yym533
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep534 := !z.EncBinary()
			yy2arr534 := z.EncBasicHandle().StructToArray
			var yyq534 [3]bool
			_, _, _ = yysep534, yyq534, yy2arr534
			const yyr534 bool = false
			if yyr534 || yy2arr534 {
				r.EncodeArrayStart(3)
			} else {
				var yynn534 int = 3
				for _, b := range yyq534 {
					if b {
						yynn534++
					}
				}
				r.EncodeMapStart(yynn534)
			}
			if yyr534 || yy2arr534 {
				yym536 := z.EncBinary()
				_ = yym536
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym537 := z.EncBinary()
				_ = yym537
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr534 || yy2arr534 {
				yym539 := z.EncBinary()
				_ = yym539
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym540 := z.EncBinary()
				_ = yym540
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr534 || yy2arr534 {
				yym542 := z.EncBinary()
				_ = yym542
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym543 := z.EncBinary()
				_ = yym543
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep534 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj550 int
	var yyb550 bool
	var yyhl550 bool = l >= 0
	yyj550++
	if yyhl550 {
		yyb550 = yyj550 > l
	} else {
		yyb550 = r.CheckBreak()
	}
	if yyb550 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj550++
	if yyhl550 {
		yyb550 = yyj550 > l
	} else {
		yyb550 = r.CheckBreak()
	}
	if yyb550 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj550++
	if yyhl550 {
		yyb550 = yyj550 > l
	} else {
		yyb550 = r.CheckBreak()
	}
	if yyb550 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj550++
		if yyhl550 {
			yyb550 = yyj550 > l
		} else {
			yyb550 = r.CheckBreak()
		}
		if yyb550 {
			break
		}
		z.DecStructFieldNotFound(yyj550-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 {
		yym554 := z.EncBinary()
		_ = yym554
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep555 := !z.EncBinary()
			yy2arr555 := z.EncBasicHandle().StructToArray
			var yyq555 [5]bool
			_, _, _ = yysep555, yyq555, yy2arr555
			const yyr555 bool = false
			yyq555[0] = x.Kind != ""
			yyq555[1] = x.APIVersion != ""
			yyq555[2] = true
			yyq555[3] = true
			yyq555[4] = true
			if yyr555 || yy2arr555 {
				r.EncodeArrayStart(5)
			} else {
				var yynn555 int = 0
				for _, b := range yyq555 {
					if b {
						yynn555++
					}
				}
				r.EncodeMapStart(yynn555)
			}
			if yyr555 || yy2arr555 {
				if yyq555[0] {
					yym557 := z.EncBinary()
					_ = yym557
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq555[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym558 := z.EncBinary()
					_ = yym558
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr555 || yy2arr555 {
				if yyq555[1] {
					yym560 := z.EncBinary()
					_ = yym560
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq555[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym561 := z.EncBinary()
					_ = yym561
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr555 || yy2arr555 {
				if yyq555[2] {
					yy563 := &x.ObjectMeta
					yy563.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq555[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy564 := &x.ObjectMeta
					yy564.CodecEncodeSelf(e)
				}
			}
			if yyr555 || yy2arr555 {
				if yyq555[3] {
					yy566 := &x.Spec
					yy566.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq555[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy567 := &x.Spec
					yy567.CodecEncodeSelf(e)
				}
			}
			if yyr555 || yy2arr555 {
				if yyq555[4] {
					yy569 := &x.Status
					yy569.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq555[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy570 := &x.Status
					yy570.CodecEncodeSelf(e)
				}
			}
			if yysep555 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj579 int
	var yyb579 bool
	var yyhl579 bool = l >= 0
	yyj579++
	if yyhl579 {
		yyb579 = yyj579 > l
	} else {
		yyb579 = r.CheckBreak()
	}
	if yyb579 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj579++
	if yyhl579 {
		yyb579 = yyj579 > l
	} else {
		yyb579 = r.CheckBreak()
	}
	if yyb579 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj579++
	if yyhl579 {
		yyb579 = yyj579 > l
	} else {
		yyb579 = r.CheckBreak()
	}
	if yyb579 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv582 := &x.ObjectMeta
		yyv582.CodecDecodeSelf(d)
	}
	yyj579++
	if yyhl579 {
		yyb579 = yyj579 > l
	} else {
		yyb579 = r.CheckBreak()
	}
	if yyb579 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv583 := &x.Spec
		yyv583.CodecDecodeSelf(d)
	}
	yyj579++
	if yyhl579 {
		yyb579 = yyj579 > l
	} else {
		yyb579 = r.CheckBreak()
	}
	if yyb579 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv584 := &x.Status
		yyv584.CodecDecodeSelf(d)
	}
	for {
		yyj579++
		if yyhl579 {
			yyb579 = yyj579 > l
		} else {
			yyb579 = r.CheckBreak()
		}
		if yyb579 {
			break
		}
		z.DecStructFieldNotFound(yyj579-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 {
		yym585 := z.EncBinary()
		_ = yym585
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep586 := !z.EncBinary()
			yy2arr586 := z.EncBasicHandle().StructToArray
			var yyq586 [4]bool
			_, _, _ = yysep586, yyq586, yy2arr586
			const yyr586 bool = false
			yyq586[0] = x.Kind != ""
			yyq586[1] = x.APIVersion != ""
			yyq586[2] = true
			if yyr586 || yy2arr586 {
				r.EncodeArrayStart(4)
			} else {
				var yynn586 int = 1
				for _, b := range yyq586 {
					if b {
						yynn586++
					}
				}
				r.EncodeMapStart(yynn586)
			}
			if yyr586 || yy2arr586 {
				if yyq586[0] {
					yym588 := z.EncBinary()
					_ = yym588
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq586[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr586 || yy2arr586 {
				if yyq586[1] {
					yym591 := z.EncBinary()
					_ = yym591
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq586[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr586 || yy2arr586 {
				if yyq586[2] {
					yy594 := &x.ListMeta
					yym595 := z.EncBinary()
					_ = yym595
					if false {
					} else if z.HasExtensions() && z.EncExt(yy594) {
					} else {
						z.EncFallback(yy594)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq586[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy596 := &x.ListMeta
					yym597 := z.EncBinary()
					_ = yym597
					if false {
					} else if z.HasExtensions() && z.EncExt(yy596) {
					} else {
						z.EncFallback(yy596)
					}
				}
			}
			if yyr586 || yy2arr586 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym599 := z.EncBinary()
					_ = yym599
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym600 := z.EncBinary()
					_ = yym600
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep586 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym601 := z.DecBinary()
	_ = yym601
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl602 := r.ReadMapStart()
			if yyl602 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl602, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl602 := r.ReadArrayStart()
			if yyl602 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl602, 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 yys603Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys603Slc
	var yyhl603 bool = l >= 0
	for yyj603 := 0; ; yyj603++ {
		if yyhl603 {
			if yyj603 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys603Slc = r.DecodeBytes(yys603Slc, true, true)
		yys603 := string(yys603Slc)
		switch yys603 {
		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 {
				yyv606 := &x.ListMeta
				yym607 := z.DecBinary()
				_ = yym607
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv606) {
				} else {
					z.DecFallback(yyv606, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv608 := &x.Items
				yym609 := z.DecBinary()
				_ = yym609
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv608), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys603)
		} // end switch yys603
	} // end for yyj603
	if !yyhl603 {
		r.ReadEnd()
	}
}

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj610 int
	var yyb610 bool
	var yyhl610 bool = l >= 0
	yyj610++
	if yyhl610 {
		yyb610 = yyj610 > l
	} else {
		yyb610 = r.CheckBreak()
	}
	if yyb610 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj610++
	if yyhl610 {
		yyb610 = yyj610 > l
	} else {
		yyb610 = r.CheckBreak()
	}
	if yyb610 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj610++
	if yyhl610 {
		yyb610 = yyj610 > l
	} else {
		yyb610 = r.CheckBreak()
	}
	if yyb610 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv613 := &x.ListMeta
		yym614 := z.DecBinary()
		_ = yym614
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv613) {
		} else {
			z.DecFallback(yyv613, false)
		}
	}
	yyj610++
	if yyhl610 {
		yyb610 = yyj610 > l
	} else {
		yyb610 = r.CheckBreak()
	}
	if yyb610 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv615 := &x.Items
		yym616 := z.DecBinary()
		_ = yym616
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv615), d)
		}
	}
	for {
		yyj610++
		if yyhl610 {
			yyb610 = yyj610 > l
		} else {
			yyb610 = r.CheckBreak()
		}
		if yyb610 {
			break
		}
		z.DecStructFieldNotFound(yyj610-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 {
		yym617 := z.EncBinary()
		_ = yym617
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep618 := !z.EncBinary()
			yy2arr618 := z.EncBasicHandle().StructToArray
			var yyq618 [4]bool
			_, _, _ = yysep618, yyq618, yy2arr618
			const yyr618 bool = false
			yyq618[0] = x.Kind != ""
			yyq618[1] = x.APIVersion != ""
			yyq618[2] = true
			if yyr618 || yy2arr618 {
				r.EncodeArrayStart(4)
			} else {
				var yynn618 int = 1
				for _, b := range yyq618 {
					if b {
						yynn618++
					}
				}
				r.EncodeMapStart(yynn618)
			}
			if yyr618 || yy2arr618 {
				if yyq618[0] {
					yym620 := z.EncBinary()
					_ = yym620
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq618[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr618 || yy2arr618 {
				if yyq618[1] {
					yym623 := z.EncBinary()
					_ = yym623
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq618[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym624 := z.EncBinary()
					_ = yym624
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr618 || yy2arr618 {
				if yyq618[2] {
					yy626 := &x.ListMeta
					yym627 := z.EncBinary()
					_ = yym627
					if false {
					} else if z.HasExtensions() && z.EncExt(yy626) {
					} else {
						z.EncFallback(yy626)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq618[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy628 := &x.ListMeta
					yym629 := z.EncBinary()
					_ = yym629
					if false {
					} else if z.HasExtensions() && z.EncExt(yy628) {
					} else {
						z.EncFallback(yy628)
					}
				}
			}
			if yyr618 || yy2arr618 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym631 := z.EncBinary()
					_ = yym631
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym632 := z.EncBinary()
					_ = yym632
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep618 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym633 := z.DecBinary()
	_ = yym633
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl634 := r.ReadMapStart()
			if yyl634 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl634, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl634 := r.ReadArrayStart()
			if yyl634 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl634, 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 yys635Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys635Slc
	var yyhl635 bool = l >= 0
	for yyj635 := 0; ; yyj635++ {
		if yyhl635 {
			if yyj635 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys635Slc = r.DecodeBytes(yys635Slc, true, true)
		yys635 := string(yys635Slc)
		switch yys635 {
		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 {
				yyv638 := &x.ListMeta
				yym639 := z.DecBinary()
				_ = yym639
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv638) {
				} else {
					z.DecFallback(yyv638, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv640 := &x.Items
				yym641 := z.DecBinary()
				_ = yym641
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv640), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys635)
		} // end switch yys635
	} // end for yyj635
	if !yyhl635 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj642 int
	var yyb642 bool
	var yyhl642 bool = l >= 0
	yyj642++
	if yyhl642 {
		yyb642 = yyj642 > l
	} else {
		yyb642 = r.CheckBreak()
	}
	if yyb642 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj642++
	if yyhl642 {
		yyb642 = yyj642 > l
	} else {
		yyb642 = r.CheckBreak()
	}
	if yyb642 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj642++
	if yyhl642 {
		yyb642 = yyj642 > l
	} else {
		yyb642 = r.CheckBreak()
	}
	if yyb642 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv645 := &x.ListMeta
		yym646 := z.DecBinary()
		_ = yym646
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv645) {
		} else {
			z.DecFallback(yyv645, false)
		}
	}
	yyj642++
	if yyhl642 {
		yyb642 = yyj642 > l
	} else {
		yyb642 = r.CheckBreak()
	}
	if yyb642 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv647 := &x.Items
		yym648 := z.DecBinary()
		_ = yym648
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv647), d)
		}
	}
	for {
		yyj642++
		if yyhl642 {
			yyb642 = yyj642 > l
		} else {
			yyb642 = r.CheckBreak()
		}
		if yyb642 {
			break
		}
		z.DecStructFieldNotFound(yyj642-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 {
		yym649 := z.EncBinary()
		_ = yym649
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep650 := !z.EncBinary()
			yy2arr650 := z.EncBasicHandle().StructToArray
			var yyq650 [5]bool
			_, _, _ = yysep650, yyq650, yy2arr650
			const yyr650 bool = false
			yyq650[0] = x.Kind != ""
			yyq650[1] = x.APIVersion != ""
			yyq650[2] = true
			yyq650[3] = true
			yyq650[4] = true
			if yyr650 || yy2arr650 {
				r.EncodeArrayStart(5)
			} else {
				var yynn650 int = 0
				for _, b := range yyq650 {
					if b {
						yynn650++
					}
				}
				r.EncodeMapStart(yynn650)
			}
			if yyr650 || yy2arr650 {
				if yyq650[0] {
					yym652 := z.EncBinary()
					_ = yym652
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq650[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr650 || yy2arr650 {
				if yyq650[1] {
					yym655 := z.EncBinary()
					_ = yym655
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq650[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym656 := z.EncBinary()
					_ = yym656
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr650 || yy2arr650 {
				if yyq650[2] {
					yy658 := &x.ObjectMeta
					yy658.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq650[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy659 := &x.ObjectMeta
					yy659.CodecEncodeSelf(e)
				}
			}
			if yyr650 || yy2arr650 {
				if yyq650[3] {
					yy661 := &x.Spec
					yy661.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq650[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy662 := &x.Spec
					yy662.CodecEncodeSelf(e)
				}
			}
			if yyr650 || yy2arr650 {
				if yyq650[4] {
					yy664 := &x.Status
					yy664.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq650[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy665 := &x.Status
					yy665.CodecEncodeSelf(e)
				}
			}
			if yysep650 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj674 int
	var yyb674 bool
	var yyhl674 bool = l >= 0
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv677 := &x.ObjectMeta
		yyv677.CodecDecodeSelf(d)
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv678 := &x.Spec
		yyv678.CodecDecodeSelf(d)
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv679 := &x.Status
		yyv679.CodecDecodeSelf(d)
	}
	for {
		yyj674++
		if yyhl674 {
			yyb674 = yyj674 > l
		} else {
			yyb674 = r.CheckBreak()
		}
		if yyb674 {
			break
		}
		z.DecStructFieldNotFound(yyj674-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 {
		yym680 := z.EncBinary()
		_ = yym680
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep681 := !z.EncBinary()
			yy2arr681 := z.EncBasicHandle().StructToArray
			var yyq681 [4]bool
			_, _, _ = yysep681, yyq681, yy2arr681
			const yyr681 bool = false
			yyq681[0] = x.Kind != ""
			yyq681[1] = x.APIVersion != ""
			yyq681[2] = true
			if yyr681 || yy2arr681 {
				r.EncodeArrayStart(4)
			} else {
				var yynn681 int = 1
				for _, b := range yyq681 {
					if b {
						yynn681++
					}
				}
				r.EncodeMapStart(yynn681)
			}
			if yyr681 || yy2arr681 {
				if yyq681[0] {
					yym683 := z.EncBinary()
					_ = yym683
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq681[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym684 := z.EncBinary()
					_ = yym684
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr681 || yy2arr681 {
				if yyq681[1] {
					yym686 := z.EncBinary()
					_ = yym686
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq681[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym687 := z.EncBinary()
					_ = yym687
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr681 || yy2arr681 {
				if yyq681[2] {
					yy689 := &x.ListMeta
					yym690 := z.EncBinary()
					_ = yym690
					if false {
					} else if z.HasExtensions() && z.EncExt(yy689) {
					} else {
						z.EncFallback(yy689)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq681[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy691 := &x.ListMeta
					yym692 := z.EncBinary()
					_ = yym692
					if false {
					} else if z.HasExtensions() && z.EncExt(yy691) {
					} else {
						z.EncFallback(yy691)
					}
				}
			}
			if yyr681 || yy2arr681 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym694 := z.EncBinary()
					_ = yym694
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym695 := z.EncBinary()
					_ = yym695
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep681 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym696 := z.DecBinary()
	_ = yym696
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl697 := r.ReadMapStart()
			if yyl697 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl697, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl697 := r.ReadArrayStart()
			if yyl697 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl697, 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 yys698Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys698Slc
	var yyhl698 bool = l >= 0
	for yyj698 := 0; ; yyj698++ {
		if yyhl698 {
			if yyj698 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys698Slc = r.DecodeBytes(yys698Slc, true, true)
		yys698 := string(yys698Slc)
		switch yys698 {
		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 {
				yyv701 := &x.ListMeta
				yym702 := z.DecBinary()
				_ = yym702
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv701) {
				} else {
					z.DecFallback(yyv701, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv703 := &x.Items
				yym704 := z.DecBinary()
				_ = yym704
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv703), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys698)
		} // end switch yys698
	} // end for yyj698
	if !yyhl698 {
		r.ReadEnd()
	}
}

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj705 int
	var yyb705 bool
	var yyhl705 bool = l >= 0
	yyj705++
	if yyhl705 {
		yyb705 = yyj705 > l
	} else {
		yyb705 = r.CheckBreak()
	}
	if yyb705 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj705++
	if yyhl705 {
		yyb705 = yyj705 > l
	} else {
		yyb705 = r.CheckBreak()
	}
	if yyb705 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj705++
	if yyhl705 {
		yyb705 = yyj705 > l
	} else {
		yyb705 = r.CheckBreak()
	}
	if yyb705 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv708 := &x.ListMeta
		yym709 := z.DecBinary()
		_ = yym709
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv708) {
		} else {
			z.DecFallback(yyv708, false)
		}
	}
	yyj705++
	if yyhl705 {
		yyb705 = yyj705 > l
	} else {
		yyb705 = r.CheckBreak()
	}
	if yyb705 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv710 := &x.Items
		yym711 := z.DecBinary()
		_ = yym711
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv710), d)
		}
	}
	for {
		yyj705++
		if yyhl705 {
			yyb705 = yyj705 > l
		} else {
			yyb705 = r.CheckBreak()
		}
		if yyb705 {
			break
		}
		z.DecStructFieldNotFound(yyj705-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 {
		yym712 := z.EncBinary()
		_ = yym712
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep713 := !z.EncBinary()
			yy2arr713 := z.EncBasicHandle().StructToArray
			var yyq713 [4]bool
			_, _, _ = yysep713, yyq713, yy2arr713
			const yyr713 bool = false
			yyq713[0] = x.Parallelism != nil
			yyq713[1] = x.Completions != nil
			yyq713[2] = x.Selector != nil
			if yyr713 || yy2arr713 {
				r.EncodeArrayStart(4)
			} else {
				var yynn713 int = 1
				for _, b := range yyq713 {
					if b {
						yynn713++
					}
				}
				r.EncodeMapStart(yynn713)
			}
			if yyr713 || yy2arr713 {
				if yyq713[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy715 := *x.Parallelism
						yym716 := z.EncBinary()
						_ = yym716
						if false {
						} else {
							r.EncodeInt(int64(yy715))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq713[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy717 := *x.Parallelism
						yym718 := z.EncBinary()
						_ = yym718
						if false {
						} else {
							r.EncodeInt(int64(yy717))
						}
					}
				}
			}
			if yyr713 || yy2arr713 {
				if yyq713[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy720 := *x.Completions
						yym721 := z.EncBinary()
						_ = yym721
						if false {
						} else {
							r.EncodeInt(int64(yy720))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq713[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy722 := *x.Completions
						yym723 := z.EncBinary()
						_ = yym723
						if false {
						} else {
							r.EncodeInt(int64(yy722))
						}
					}
				}
			}
			if yyr713 || yy2arr713 {
				if yyq713[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq713[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr713 || yy2arr713 {
				yy726 := &x.Template
				yy726.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy727 := &x.Template
				yy727.CodecEncodeSelf(e)
			}
			if yysep713 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym728 := z.DecBinary()
	_ = yym728
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl729 := r.ReadMapStart()
			if yyl729 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl729, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl729 := r.ReadArrayStart()
			if yyl729 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl729, 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 yys730Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys730Slc
	var yyhl730 bool = l >= 0
	for yyj730 := 0; ; yyj730++ {
		if yyhl730 {
			if yyj730 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys730Slc = r.DecodeBytes(yys730Slc, true, true)
		yys730 := string(yys730Slc)
		switch yys730 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int)
				}
				yym732 := z.DecBinary()
				_ = yym732
				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)
				}
				yym734 := z.DecBinary()
				_ = yym734
				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_v1.PodTemplateSpec{}
			} else {
				yyv736 := &x.Template
				yyv736.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys730)
		} // end switch yys730
	} // end for yyj730
	if !yyhl730 {
		r.ReadEnd()
	}
}

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj737 int
	var yyb737 bool
	var yyhl737 bool = l >= 0
	yyj737++
	if yyhl737 {
		yyb737 = yyj737 > l
	} else {
		yyb737 = r.CheckBreak()
	}
	if yyb737 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int)
		}
		yym739 := z.DecBinary()
		_ = yym739
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj737++
	if yyhl737 {
		yyb737 = yyj737 > l
	} else {
		yyb737 = r.CheckBreak()
	}
	if yyb737 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int)
		}
		yym741 := z.DecBinary()
		_ = yym741
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj737++
	if yyhl737 {
		yyb737 = yyj737 > l
	} else {
		yyb737 = r.CheckBreak()
	}
	if yyb737 {
		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)
	}
	yyj737++
	if yyhl737 {
		yyb737 = yyj737 > l
	} else {
		yyb737 = r.CheckBreak()
	}
	if yyb737 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv743 := &x.Template
		yyv743.CodecDecodeSelf(d)
	}
	for {
		yyj737++
		if yyhl737 {
			yyb737 = yyj737 > l
		} else {
			yyb737 = r.CheckBreak()
		}
		if yyb737 {
			break
		}
		z.DecStructFieldNotFound(yyj737-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 {
		yym744 := z.EncBinary()
		_ = yym744
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep745 := !z.EncBinary()
			yy2arr745 := z.EncBasicHandle().StructToArray
			var yyq745 [6]bool
			_, _, _ = yysep745, yyq745, yy2arr745
			const yyr745 bool = false
			yyq745[0] = len(x.Conditions) != 0
			yyq745[1] = x.StartTime != nil
			yyq745[2] = x.CompletionTime != nil
			yyq745[3] = x.Active != 0
			yyq745[4] = x.Succeeded != 0
			yyq745[5] = x.Failed != 0
			if yyr745 || yy2arr745 {
				r.EncodeArrayStart(6)
			} else {
				var yynn745 int = 0
				for _, b := range yyq745 {
					if b {
						yynn745++
					}
				}
				r.EncodeMapStart(yynn745)
			}
			if yyr745 || yy2arr745 {
				if yyq745[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym747 := z.EncBinary()
						_ = yym747
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq745[0] {
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym748 := z.EncBinary()
						_ = yym748
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr745 || yy2arr745 {
				if yyq745[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym750 := z.EncBinary()
						_ = yym750
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym750 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym750 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq745[1] {
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym751 := z.EncBinary()
						_ = yym751
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym751 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym751 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr745 || yy2arr745 {
				if yyq745[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym753 := z.EncBinary()
						_ = yym753
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym753 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym753 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq745[2] {
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym754 := z.EncBinary()
						_ = yym754
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym754 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym754 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr745 || yy2arr745 {
				if yyq745[3] {
					yym756 := z.EncBinary()
					_ = yym756
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq745[3] {
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					yym757 := z.EncBinary()
					_ = yym757
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr745 || yy2arr745 {
				if yyq745[4] {
					yym759 := z.EncBinary()
					_ = yym759
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq745[4] {
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					yym760 := z.EncBinary()
					_ = yym760
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr745 || yy2arr745 {
				if yyq745[5] {
					yym762 := z.EncBinary()
					_ = yym762
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq745[5] {
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					yym763 := z.EncBinary()
					_ = yym763
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yysep745 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym764 := z.DecBinary()
	_ = yym764
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl765 := r.ReadMapStart()
			if yyl765 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl765, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl765 := r.ReadArrayStart()
			if yyl765 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl765, 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 yys766Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys766Slc
	var yyhl766 bool = l >= 0
	for yyj766 := 0; ; yyj766++ {
		if yyhl766 {
			if yyj766 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys766Slc = r.DecodeBytes(yys766Slc, true, true)
		yys766 := string(yys766Slc)
		switch yys766 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv767 := &x.Conditions
				yym768 := z.DecBinary()
				_ = yym768
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv767), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym770 := z.DecBinary()
				_ = yym770
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym770 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym770 && 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)
				}
				yym772 := z.DecBinary()
				_ = yym772
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym772 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym772 && 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, yys766)
		} // end switch yys766
	} // end for yyj766
	if !yyhl766 {
		r.ReadEnd()
	}
}

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

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym786 := z.EncBinary()
	_ = yym786
	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
	yym787 := z.DecBinary()
	_ = yym787
	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 {
		yym788 := z.EncBinary()
		_ = yym788
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep789 := !z.EncBinary()
			yy2arr789 := z.EncBasicHandle().StructToArray
			var yyq789 [6]bool
			_, _, _ = yysep789, yyq789, yy2arr789
			const yyr789 bool = false
			yyq789[2] = true
			yyq789[3] = true
			yyq789[4] = x.Reason != ""
			yyq789[5] = x.Message != ""
			if yyr789 || yy2arr789 {
				r.EncodeArrayStart(6)
			} else {
				var yynn789 int = 2
				for _, b := range yyq789 {
					if b {
						yynn789++
					}
				}
				r.EncodeMapStart(yynn789)
			}
			if yyr789 || yy2arr789 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr789 || yy2arr789 {
				yym792 := z.EncBinary()
				_ = yym792
				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"))
				yym793 := z.EncBinary()
				_ = yym793
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr789 || yy2arr789 {
				if yyq789[2] {
					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)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq789[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy797 := &x.LastProbeTime
					yym798 := z.EncBinary()
					_ = yym798
					if false {
					} else if z.HasExtensions() && z.EncExt(yy797) {
					} else if yym798 {
						z.EncBinaryMarshal(yy797)
					} else if !yym798 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy797)
					} else {
						z.EncFallback(yy797)
					}
				}
			}
			if yyr789 || yy2arr789 {
				if yyq789[3] {
					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)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq789[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy802 := &x.LastTransitionTime
					yym803 := z.EncBinary()
					_ = yym803
					if false {
					} else if z.HasExtensions() && z.EncExt(yy802) {
					} else if yym803 {
						z.EncBinaryMarshal(yy802)
					} else if !yym803 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy802)
					} else {
						z.EncFallback(yy802)
					}
				}
			}
			if yyr789 || yy2arr789 {
				if yyq789[4] {
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq789[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym806 := z.EncBinary()
					_ = yym806
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr789 || yy2arr789 {
				if yyq789[5] {
					yym808 := z.EncBinary()
					_ = yym808
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq789[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym809 := z.EncBinary()
					_ = yym809
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep789 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj821 int
	var yyb821 bool
	var yyhl821 bool = l >= 0
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv824 := &x.LastProbeTime
		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)
		}
	}
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv826 := &x.LastTransitionTime
		yym827 := z.DecBinary()
		_ = yym827
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv826) {
		} else if yym827 {
			z.DecBinaryUnmarshal(yyv826)
		} else if !yym827 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv826)
		} else {
			z.DecFallback(yyv826, false)
		}
	}
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj821++
	if yyhl821 {
		yyb821 = yyj821 > l
	} else {
		yyb821 = r.CheckBreak()
	}
	if yyb821 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj821++
		if yyhl821 {
			yyb821 = yyj821 > l
		} else {
			yyb821 = r.CheckBreak()
		}
		if yyb821 {
			break
		}
		z.DecStructFieldNotFound(yyj821-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 {
		yym830 := z.EncBinary()
		_ = yym830
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep831 := !z.EncBinary()
			yy2arr831 := z.EncBasicHandle().StructToArray
			var yyq831 [5]bool
			_, _, _ = yysep831, yyq831, yy2arr831
			const yyr831 bool = false
			yyq831[0] = x.Kind != ""
			yyq831[1] = x.APIVersion != ""
			yyq831[2] = true
			yyq831[3] = true
			yyq831[4] = true
			if yyr831 || yy2arr831 {
				r.EncodeArrayStart(5)
			} else {
				var yynn831 int = 0
				for _, b := range yyq831 {
					if b {
						yynn831++
					}
				}
				r.EncodeMapStart(yynn831)
			}
			if yyr831 || yy2arr831 {
				if yyq831[0] {
					yym833 := z.EncBinary()
					_ = yym833
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym834 := z.EncBinary()
					_ = yym834
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr831 || yy2arr831 {
				if yyq831[1] {
					yym836 := z.EncBinary()
					_ = yym836
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym837 := z.EncBinary()
					_ = yym837
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr831 || yy2arr831 {
				if yyq831[2] {
					yy839 := &x.ObjectMeta
					yy839.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy840 := &x.ObjectMeta
					yy840.CodecEncodeSelf(e)
				}
			}
			if yyr831 || yy2arr831 {
				if yyq831[3] {
					yy842 := &x.Spec
					yy842.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy843 := &x.Spec
					yy843.CodecEncodeSelf(e)
				}
			}
			if yyr831 || yy2arr831 {
				if yyq831[4] {
					yy845 := &x.Status
					yy845.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy846 := &x.Status
					yy846.CodecEncodeSelf(e)
				}
			}
			if yysep831 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj855 int
	var yyb855 bool
	var yyhl855 bool = l >= 0
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv858 := &x.ObjectMeta
		yyv858.CodecDecodeSelf(d)
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv859 := &x.Spec
		yyv859.CodecDecodeSelf(d)
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv860 := &x.Status
		yyv860.CodecDecodeSelf(d)
	}
	for {
		yyj855++
		if yyhl855 {
			yyb855 = yyj855 > l
		} else {
			yyb855 = r.CheckBreak()
		}
		if yyb855 {
			break
		}
		z.DecStructFieldNotFound(yyj855-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 {
		yym861 := z.EncBinary()
		_ = yym861
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep862 := !z.EncBinary()
			yy2arr862 := z.EncBasicHandle().StructToArray
			var yyq862 [4]bool
			_, _, _ = yysep862, yyq862, yy2arr862
			const yyr862 bool = false
			yyq862[0] = x.Kind != ""
			yyq862[1] = x.APIVersion != ""
			yyq862[2] = true
			if yyr862 || yy2arr862 {
				r.EncodeArrayStart(4)
			} else {
				var yynn862 int = 1
				for _, b := range yyq862 {
					if b {
						yynn862++
					}
				}
				r.EncodeMapStart(yynn862)
			}
			if yyr862 || yy2arr862 {
				if yyq862[0] {
					yym864 := z.EncBinary()
					_ = yym864
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq862[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym865 := z.EncBinary()
					_ = yym865
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr862 || yy2arr862 {
				if yyq862[1] {
					yym867 := z.EncBinary()
					_ = yym867
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq862[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym868 := z.EncBinary()
					_ = yym868
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr862 || yy2arr862 {
				if yyq862[2] {
					yy870 := &x.ListMeta
					yym871 := z.EncBinary()
					_ = yym871
					if false {
					} else if z.HasExtensions() && z.EncExt(yy870) {
					} else {
						z.EncFallback(yy870)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq862[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy872 := &x.ListMeta
					yym873 := z.EncBinary()
					_ = yym873
					if false {
					} else if z.HasExtensions() && z.EncExt(yy872) {
					} else {
						z.EncFallback(yy872)
					}
				}
			}
			if yyr862 || yy2arr862 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym875 := z.EncBinary()
					_ = yym875
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym876 := z.EncBinary()
					_ = yym876
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep862 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym877 := z.DecBinary()
	_ = yym877
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl878 := r.ReadMapStart()
			if yyl878 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl878, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl878 := r.ReadArrayStart()
			if yyl878 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl878, 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 yys879Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys879Slc
	var yyhl879 bool = l >= 0
	for yyj879 := 0; ; yyj879++ {
		if yyhl879 {
			if yyj879 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys879Slc = r.DecodeBytes(yys879Slc, true, true)
		yys879 := string(yys879Slc)
		switch yys879 {
		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 {
				yyv882 := &x.ListMeta
				yym883 := z.DecBinary()
				_ = yym883
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv882) {
				} else {
					z.DecFallback(yyv882, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv884 := &x.Items
				yym885 := z.DecBinary()
				_ = yym885
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv884), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys879)
		} // end switch yys879
	} // end for yyj879
	if !yyhl879 {
		r.ReadEnd()
	}
}

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj886 int
	var yyb886 bool
	var yyhl886 bool = l >= 0
	yyj886++
	if yyhl886 {
		yyb886 = yyj886 > l
	} else {
		yyb886 = r.CheckBreak()
	}
	if yyb886 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj886++
	if yyhl886 {
		yyb886 = yyj886 > l
	} else {
		yyb886 = r.CheckBreak()
	}
	if yyb886 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj886++
	if yyhl886 {
		yyb886 = yyj886 > l
	} else {
		yyb886 = r.CheckBreak()
	}
	if yyb886 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv889 := &x.ListMeta
		yym890 := z.DecBinary()
		_ = yym890
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv889) {
		} else {
			z.DecFallback(yyv889, false)
		}
	}
	yyj886++
	if yyhl886 {
		yyb886 = yyj886 > l
	} else {
		yyb886 = r.CheckBreak()
	}
	if yyb886 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv891 := &x.Items
		yym892 := z.DecBinary()
		_ = yym892
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv891), d)
		}
	}
	for {
		yyj886++
		if yyhl886 {
			yyb886 = yyj886 > l
		} else {
			yyb886 = r.CheckBreak()
		}
		if yyb886 {
			break
		}
		z.DecStructFieldNotFound(yyj886-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 {
		yym893 := z.EncBinary()
		_ = yym893
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep894 := !z.EncBinary()
			yy2arr894 := z.EncBasicHandle().StructToArray
			var yyq894 [2]bool
			_, _, _ = yysep894, yyq894, yy2arr894
			const yyr894 bool = false
			yyq894[0] = x.Backend != nil
			yyq894[1] = len(x.Rules) != 0
			if yyr894 || yy2arr894 {
				r.EncodeArrayStart(2)
			} else {
				var yynn894 int = 0
				for _, b := range yyq894 {
					if b {
						yynn894++
					}
				}
				r.EncodeMapStart(yynn894)
			}
			if yyr894 || yy2arr894 {
				if yyq894[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq894[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr894 || yy2arr894 {
				if yyq894[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym897 := z.EncBinary()
						_ = yym897
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq894[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym898 := z.EncBinary()
						_ = yym898
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep894 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym899 := z.DecBinary()
	_ = yym899
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl900 := r.ReadMapStart()
			if yyl900 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl900, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl900 := r.ReadArrayStart()
			if yyl900 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl900, 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 yys901Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys901Slc
	var yyhl901 bool = l >= 0
	for yyj901 := 0; ; yyj901++ {
		if yyhl901 {
			if yyj901 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys901Slc = r.DecodeBytes(yys901Slc, true, true)
		yys901 := string(yys901Slc)
		switch yys901 {
		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 {
				yyv903 := &x.Rules
				yym904 := z.DecBinary()
				_ = yym904
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv903), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys901)
		} // end switch yys901
	} // end for yyj901
	if !yyhl901 {
		r.ReadEnd()
	}
}

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj905 int
	var yyb905 bool
	var yyhl905 bool = l >= 0
	yyj905++
	if yyhl905 {
		yyb905 = yyj905 > l
	} else {
		yyb905 = r.CheckBreak()
	}
	if yyb905 {
		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)
	}
	yyj905++
	if yyhl905 {
		yyb905 = yyj905 > l
	} else {
		yyb905 = r.CheckBreak()
	}
	if yyb905 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv907 := &x.Rules
		yym908 := z.DecBinary()
		_ = yym908
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv907), d)
		}
	}
	for {
		yyj905++
		if yyhl905 {
			yyb905 = yyj905 > l
		} else {
			yyb905 = r.CheckBreak()
		}
		if yyb905 {
			break
		}
		z.DecStructFieldNotFound(yyj905-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 {
		yym909 := z.EncBinary()
		_ = yym909
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep910 := !z.EncBinary()
			yy2arr910 := z.EncBasicHandle().StructToArray
			var yyq910 [1]bool
			_, _, _ = yysep910, yyq910, yy2arr910
			const yyr910 bool = false
			yyq910[0] = true
			if yyr910 || yy2arr910 {
				r.EncodeArrayStart(1)
			} else {
				var yynn910 int = 0
				for _, b := range yyq910 {
					if b {
						yynn910++
					}
				}
				r.EncodeMapStart(yynn910)
			}
			if yyr910 || yy2arr910 {
				if yyq910[0] {
					yy912 := &x.LoadBalancer
					yy912.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq910[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy913 := &x.LoadBalancer
					yy913.CodecEncodeSelf(e)
				}
			}
			if yysep910 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj918 int
	var yyb918 bool
	var yyhl918 bool = l >= 0
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv919 := &x.LoadBalancer
		yyv919.CodecDecodeSelf(d)
	}
	for {
		yyj918++
		if yyhl918 {
			yyb918 = yyj918 > l
		} else {
			yyb918 = r.CheckBreak()
		}
		if yyb918 {
			break
		}
		z.DecStructFieldNotFound(yyj918-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 {
		yym920 := z.EncBinary()
		_ = yym920
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep921 := !z.EncBinary()
			yy2arr921 := z.EncBasicHandle().StructToArray
			var yyq921 [2]bool
			_, _, _ = yysep921, yyq921, yy2arr921
			const yyr921 bool = false
			yyq921[0] = x.Host != ""
			yyq921[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr921 || yy2arr921 {
				r.EncodeArrayStart(2)
			} else {
				var yynn921 int = 0
				for _, b := range yyq921 {
					if b {
						yynn921++
					}
				}
				r.EncodeMapStart(yynn921)
			}
			if yyr921 || yy2arr921 {
				if yyq921[0] {
					yym923 := z.EncBinary()
					_ = yym923
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq921[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym924 := z.EncBinary()
					_ = yym924
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn925 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn925 = true
				goto LABEL925
			}
		LABEL925:
			if yyr921 || yy2arr921 {
				if yyn925 {
					r.EncodeNil()
				} else {
					if yyq921[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq921[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn925 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep921 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj931 int
	var yyb931 bool
	var yyhl931 bool = l >= 0
	yyj931++
	if yyhl931 {
		yyb931 = yyj931 > l
	} else {
		yyb931 = r.CheckBreak()
	}
	if yyb931 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Host = ""
	} else {
		x.Host = string(r.DecodeString())
	}
	yyj931++
	if yyhl931 {
		yyb931 = yyj931 > l
	} else {
		yyb931 = r.CheckBreak()
	}
	if yyb931 {
		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 {
		yyj931++
		if yyhl931 {
			yyb931 = yyj931 > l
		} else {
			yyb931 = r.CheckBreak()
		}
		if yyb931 {
			break
		}
		z.DecStructFieldNotFound(yyj931-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 {
		yym934 := z.EncBinary()
		_ = yym934
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep935 := !z.EncBinary()
			yy2arr935 := z.EncBasicHandle().StructToArray
			var yyq935 [1]bool
			_, _, _ = yysep935, yyq935, yy2arr935
			const yyr935 bool = false
			yyq935[0] = x.HTTP != nil
			if yyr935 || yy2arr935 {
				r.EncodeArrayStart(1)
			} else {
				var yynn935 int = 0
				for _, b := range yyq935 {
					if b {
						yynn935++
					}
				}
				r.EncodeMapStart(yynn935)
			}
			if yyr935 || yy2arr935 {
				if yyq935[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq935[0] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				}
			}
			if yysep935 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj941 int
	var yyb941 bool
	var yyhl941 bool = l >= 0
	yyj941++
	if yyhl941 {
		yyb941 = yyj941 > l
	} else {
		yyb941 = r.CheckBreak()
	}
	if yyb941 {
		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 {
		yyj941++
		if yyhl941 {
			yyb941 = yyj941 > l
		} else {
			yyb941 = r.CheckBreak()
		}
		if yyb941 {
			break
		}
		z.DecStructFieldNotFound(yyj941-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 {
		yym943 := z.EncBinary()
		_ = yym943
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep944 := !z.EncBinary()
			yy2arr944 := z.EncBasicHandle().StructToArray
			var yyq944 [1]bool
			_, _, _ = yysep944, yyq944, yy2arr944
			const yyr944 bool = false
			if yyr944 || yy2arr944 {
				r.EncodeArrayStart(1)
			} else {
				var yynn944 int = 1
				for _, b := range yyq944 {
					if b {
						yynn944++
					}
				}
				r.EncodeMapStart(yynn944)
			}
			if yyr944 || yy2arr944 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym946 := z.EncBinary()
					_ = yym946
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym947 := z.EncBinary()
					_ = yym947
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep944 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj953 int
	var yyb953 bool
	var yyhl953 bool = l >= 0
	yyj953++
	if yyhl953 {
		yyb953 = yyj953 > l
	} else {
		yyb953 = r.CheckBreak()
	}
	if yyb953 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv954 := &x.Paths
		yym955 := z.DecBinary()
		_ = yym955
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv954), d)
		}
	}
	for {
		yyj953++
		if yyhl953 {
			yyb953 = yyj953 > l
		} else {
			yyb953 = r.CheckBreak()
		}
		if yyb953 {
			break
		}
		z.DecStructFieldNotFound(yyj953-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 {
		yym956 := z.EncBinary()
		_ = yym956
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep957 := !z.EncBinary()
			yy2arr957 := z.EncBasicHandle().StructToArray
			var yyq957 [2]bool
			_, _, _ = yysep957, yyq957, yy2arr957
			const yyr957 bool = false
			yyq957[0] = x.Path != ""
			if yyr957 || yy2arr957 {
				r.EncodeArrayStart(2)
			} else {
				var yynn957 int = 1
				for _, b := range yyq957 {
					if b {
						yynn957++
					}
				}
				r.EncodeMapStart(yynn957)
			}
			if yyr957 || yy2arr957 {
				if yyq957[0] {
					yym959 := z.EncBinary()
					_ = yym959
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq957[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym960 := z.EncBinary()
					_ = yym960
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr957 || yy2arr957 {
				yy962 := &x.Backend
				yy962.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy963 := &x.Backend
				yy963.CodecEncodeSelf(e)
			}
			if yysep957 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj969 int
	var yyb969 bool
	var yyhl969 bool = l >= 0
	yyj969++
	if yyhl969 {
		yyb969 = yyj969 > l
	} else {
		yyb969 = r.CheckBreak()
	}
	if yyb969 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj969++
	if yyhl969 {
		yyb969 = yyj969 > l
	} else {
		yyb969 = r.CheckBreak()
	}
	if yyb969 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv971 := &x.Backend
		yyv971.CodecDecodeSelf(d)
	}
	for {
		yyj969++
		if yyhl969 {
			yyb969 = yyj969 > l
		} else {
			yyb969 = r.CheckBreak()
		}
		if yyb969 {
			break
		}
		z.DecStructFieldNotFound(yyj969-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 {
		yym972 := z.EncBinary()
		_ = yym972
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep973 := !z.EncBinary()
			yy2arr973 := z.EncBasicHandle().StructToArray
			var yyq973 [2]bool
			_, _, _ = yysep973, yyq973, yy2arr973
			const yyr973 bool = false
			if yyr973 || yy2arr973 {
				r.EncodeArrayStart(2)
			} else {
				var yynn973 int = 2
				for _, b := range yyq973 {
					if b {
						yynn973++
					}
				}
				r.EncodeMapStart(yynn973)
			}
			if yyr973 || yy2arr973 {
				yym975 := z.EncBinary()
				_ = yym975
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym976 := z.EncBinary()
				_ = yym976
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr973 || yy2arr973 {
				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)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy980 := &x.ServicePort
				yym981 := z.EncBinary()
				_ = yym981
				if false {
				} else if z.HasExtensions() && z.EncExt(yy980) {
				} else if !yym981 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy980)
				} else {
					z.EncFallback(yy980)
				}
			}
			if yysep973 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym992 := z.EncBinary()
	_ = yym992
	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
	yym993 := z.DecBinary()
	_ = yym993
	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 {
		yym994 := z.EncBinary()
		_ = yym994
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep995 := !z.EncBinary()
			yy2arr995 := z.EncBasicHandle().StructToArray
			var yyq995 [2]bool
			_, _, _ = yysep995, yyq995, yy2arr995
			const yyr995 bool = false
			if yyr995 || yy2arr995 {
				r.EncodeArrayStart(2)
			} else {
				var yynn995 int = 2
				for _, b := range yyq995 {
					if b {
						yynn995++
					}
				}
				r.EncodeMapStart(yynn995)
			}
			if yyr995 || yy2arr995 {
				x.Resource.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("resource"))
				x.Resource.CodecEncodeSelf(e)
			}
			if yyr995 || yy2arr995 {
				yym998 := z.EncBinary()
				_ = yym998
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				yym999 := z.EncBinary()
				_ = yym999
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yysep995 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *NodeUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1005 int
	var yyb1005 bool
	var yyhl1005 bool = l >= 0
	yyj1005++
	if yyhl1005 {
		yyb1005 = yyj1005 > l
	} else {
		yyb1005 = r.CheckBreak()
	}
	if yyb1005 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj1005++
	if yyhl1005 {
		yyb1005 = yyj1005 > l
	} else {
		yyb1005 = r.CheckBreak()
	}
	if yyb1005 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj1005++
		if yyhl1005 {
			yyb1005 = yyj1005 > l
		} else {
			yyb1005 = r.CheckBreak()
		}
		if yyb1005 {
			break
		}
		z.DecStructFieldNotFound(yyj1005-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 {
		yym1008 := z.EncBinary()
		_ = yym1008
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1009 := !z.EncBinary()
			yy2arr1009 := z.EncBasicHandle().StructToArray
			var yyq1009 [3]bool
			_, _, _ = yysep1009, yyq1009, yy2arr1009
			const yyr1009 bool = false
			if yyr1009 || yy2arr1009 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1009 int = 3
				for _, b := range yyq1009 {
					if b {
						yynn1009++
					}
				}
				r.EncodeMapStart(yynn1009)
			}
			if yyr1009 || yy2arr1009 {
				yym1011 := z.EncBinary()
				_ = yym1011
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				yym1012 := z.EncBinary()
				_ = yym1012
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1009 || yy2arr1009 {
				yym1014 := z.EncBinary()
				_ = yym1014
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				yym1015 := z.EncBinary()
				_ = yym1015
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1009 || yy2arr1009 {
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1017 := z.EncBinary()
					_ = yym1017
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1018 := z.EncBinary()
					_ = yym1018
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yysep1009 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1019 := z.DecBinary()
	_ = yym1019
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1020 := r.ReadMapStart()
			if yyl1020 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1020, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1020 := r.ReadArrayStart()
			if yyl1020 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1020, 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 yys1021Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1021Slc
	var yyhl1021 bool = l >= 0
	for yyj1021 := 0; ; yyj1021++ {
		if yyhl1021 {
			if yyj1021 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1021Slc = r.DecodeBytes(yys1021Slc, true, true)
		yys1021 := string(yys1021Slc)
		switch yys1021 {
		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 {
				yyv1024 := &x.TargetUtilization
				yym1025 := z.DecBinary()
				_ = yym1025
				if false {
				} else {
					h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1024), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1021)
		} // end switch yys1021
	} // end for yyj1021
	if !yyhl1021 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1026 int
	var yyb1026 bool
	var yyhl1026 bool = l >= 0
	yyj1026++
	if yyhl1026 {
		yyb1026 = yyj1026 > l
	} else {
		yyb1026 = r.CheckBreak()
	}
	if yyb1026 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1026++
	if yyhl1026 {
		yyb1026 = yyj1026 > l
	} else {
		yyb1026 = r.CheckBreak()
	}
	if yyb1026 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1026++
	if yyhl1026 {
		yyb1026 = yyj1026 > l
	} else {
		yyb1026 = r.CheckBreak()
	}
	if yyb1026 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1029 := &x.TargetUtilization
		yym1030 := z.DecBinary()
		_ = yym1030
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1029), d)
		}
	}
	for {
		yyj1026++
		if yyhl1026 {
			yyb1026 = yyj1026 > l
		} else {
			yyb1026 = r.CheckBreak()
		}
		if yyb1026 {
			break
		}
		z.DecStructFieldNotFound(yyj1026-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 {
		yym1031 := z.EncBinary()
		_ = yym1031
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1032 := !z.EncBinary()
			yy2arr1032 := z.EncBasicHandle().StructToArray
			var yyq1032 [4]bool
			_, _, _ = yysep1032, yyq1032, yy2arr1032
			const yyr1032 bool = false
			yyq1032[0] = x.Kind != ""
			yyq1032[1] = x.APIVersion != ""
			yyq1032[2] = true
			yyq1032[3] = true
			if yyr1032 || yy2arr1032 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1032 int = 0
				for _, b := range yyq1032 {
					if b {
						yynn1032++
					}
				}
				r.EncodeMapStart(yynn1032)
			}
			if yyr1032 || yy2arr1032 {
				if yyq1032[0] {
					yym1034 := z.EncBinary()
					_ = yym1034
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1032[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1035 := z.EncBinary()
					_ = yym1035
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1032 || yy2arr1032 {
				if yyq1032[1] {
					yym1037 := z.EncBinary()
					_ = yym1037
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1032[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1038 := z.EncBinary()
					_ = yym1038
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1032 || yy2arr1032 {
				if yyq1032[2] {
					yy1040 := &x.ObjectMeta
					yy1040.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1032[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1041 := &x.ObjectMeta
					yy1041.CodecEncodeSelf(e)
				}
			}
			if yyr1032 || yy2arr1032 {
				if yyq1032[3] {
					yy1043 := &x.Spec
					yy1043.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1032[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1044 := &x.Spec
					yy1044.CodecEncodeSelf(e)
				}
			}
			if yysep1032 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1052 int
	var yyb1052 bool
	var yyhl1052 bool = l >= 0
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1055 := &x.ObjectMeta
		yyv1055.CodecDecodeSelf(d)
	}
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1056 := &x.Spec
		yyv1056.CodecDecodeSelf(d)
	}
	for {
		yyj1052++
		if yyhl1052 {
			yyb1052 = yyj1052 > l
		} else {
			yyb1052 = r.CheckBreak()
		}
		if yyb1052 {
			break
		}
		z.DecStructFieldNotFound(yyj1052-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 {
		yym1057 := z.EncBinary()
		_ = yym1057
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1058 := !z.EncBinary()
			yy2arr1058 := z.EncBasicHandle().StructToArray
			var yyq1058 [4]bool
			_, _, _ = yysep1058, yyq1058, yy2arr1058
			const yyr1058 bool = false
			yyq1058[0] = x.Kind != ""
			yyq1058[1] = x.APIVersion != ""
			yyq1058[2] = true
			if yyr1058 || yy2arr1058 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1058 int = 1
				for _, b := range yyq1058 {
					if b {
						yynn1058++
					}
				}
				r.EncodeMapStart(yynn1058)
			}
			if yyr1058 || yy2arr1058 {
				if yyq1058[0] {
					yym1060 := z.EncBinary()
					_ = yym1060
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1058[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1061 := z.EncBinary()
					_ = yym1061
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1058 || yy2arr1058 {
				if yyq1058[1] {
					yym1063 := z.EncBinary()
					_ = yym1063
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1058[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1064 := z.EncBinary()
					_ = yym1064
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1058 || yy2arr1058 {
				if yyq1058[2] {
					yy1066 := &x.ListMeta
					yym1067 := z.EncBinary()
					_ = yym1067
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1066) {
					} else {
						z.EncFallback(yy1066)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1058[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1068 := &x.ListMeta
					yym1069 := z.EncBinary()
					_ = yym1069
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1068) {
					} else {
						z.EncFallback(yy1068)
					}
				}
			}
			if yyr1058 || yy2arr1058 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1071 := z.EncBinary()
					_ = yym1071
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1072 := z.EncBinary()
					_ = yym1072
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1058 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1073 := z.DecBinary()
	_ = yym1073
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1074 := r.ReadMapStart()
			if yyl1074 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1074, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1074 := r.ReadArrayStart()
			if yyl1074 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1074, 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 yys1075Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1075Slc
	var yyhl1075 bool = l >= 0
	for yyj1075 := 0; ; yyj1075++ {
		if yyhl1075 {
			if yyj1075 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1075Slc = r.DecodeBytes(yys1075Slc, true, true)
		yys1075 := string(yys1075Slc)
		switch yys1075 {
		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 {
				yyv1078 := &x.ListMeta
				yym1079 := z.DecBinary()
				_ = yym1079
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1078) {
				} else {
					z.DecFallback(yyv1078, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1080 := &x.Items
				yym1081 := z.DecBinary()
				_ = yym1081
				if false {
				} else {
					h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1080), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1075)
		} // end switch yys1075
	} // end for yyj1075
	if !yyhl1075 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1082 int
	var yyb1082 bool
	var yyhl1082 bool = l >= 0
	yyj1082++
	if yyhl1082 {
		yyb1082 = yyj1082 > l
	} else {
		yyb1082 = r.CheckBreak()
	}
	if yyb1082 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1082++
	if yyhl1082 {
		yyb1082 = yyj1082 > l
	} else {
		yyb1082 = r.CheckBreak()
	}
	if yyb1082 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1082++
	if yyhl1082 {
		yyb1082 = yyj1082 > l
	} else {
		yyb1082 = r.CheckBreak()
	}
	if yyb1082 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1085 := &x.ListMeta
		yym1086 := z.DecBinary()
		_ = yym1086
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1085) {
		} else {
			z.DecFallback(yyv1085, false)
		}
	}
	yyj1082++
	if yyhl1082 {
		yyb1082 = yyj1082 > l
	} else {
		yyb1082 = r.CheckBreak()
	}
	if yyb1082 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1087 := &x.Items
		yym1088 := z.DecBinary()
		_ = yym1088
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1087), d)
		}
	}
	for {
		yyj1082++
		if yyhl1082 {
			yyb1082 = yyj1082 > l
		} else {
			yyb1082 = r.CheckBreak()
		}
		if yyb1082 {
			break
		}
		z.DecStructFieldNotFound(yyj1082-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 {
		yym1089 := z.EncBinary()
		_ = yym1089
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1090 := !z.EncBinary()
			yy2arr1090 := z.EncBasicHandle().StructToArray
			var yyq1090 [2]bool
			_, _, _ = yysep1090, yyq1090, yy2arr1090
			const yyr1090 bool = false
			yyq1090[0] = len(x.MatchLabels) != 0
			yyq1090[1] = len(x.MatchExpressions) != 0
			if yyr1090 || yy2arr1090 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1090 int = 0
				for _, b := range yyq1090 {
					if b {
						yynn1090++
					}
				}
				r.EncodeMapStart(yynn1090)
			}
			if yyr1090 || yy2arr1090 {
				if yyq1090[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1092 := z.EncBinary()
						_ = yym1092
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1090[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1093 := z.EncBinary()
						_ = yym1093
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1090 || yy2arr1090 {
				if yyq1090[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1095 := z.EncBinary()
						_ = yym1095
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1090[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1096 := z.EncBinary()
						_ = yym1096
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1090 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *PodSelector) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1097 := z.DecBinary()
	_ = yym1097
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1098 := r.ReadMapStart()
			if yyl1098 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1098, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1098 := r.ReadArrayStart()
			if yyl1098 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1098, 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 yys1099Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1099Slc
	var yyhl1099 bool = l >= 0
	for yyj1099 := 0; ; yyj1099++ {
		if yyhl1099 {
			if yyj1099 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1099Slc = r.DecodeBytes(yys1099Slc, true, true)
		yys1099 := string(yys1099Slc)
		switch yys1099 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1100 := &x.MatchLabels
				yym1101 := z.DecBinary()
				_ = yym1101
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1100, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1102 := &x.MatchExpressions
				yym1103 := z.DecBinary()
				_ = yym1103
				if false {
				} else {
					h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1102), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1099)
		} // end switch yys1099
	} // end for yyj1099
	if !yyhl1099 {
		r.ReadEnd()
	}
}

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1104 int
	var yyb1104 bool
	var yyhl1104 bool = l >= 0
	yyj1104++
	if yyhl1104 {
		yyb1104 = yyj1104 > l
	} else {
		yyb1104 = r.CheckBreak()
	}
	if yyb1104 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1105 := &x.MatchLabels
		yym1106 := z.DecBinary()
		_ = yym1106
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1105, false, d)
		}
	}
	yyj1104++
	if yyhl1104 {
		yyb1104 = yyj1104 > l
	} else {
		yyb1104 = r.CheckBreak()
	}
	if yyb1104 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1107 := &x.MatchExpressions
		yym1108 := z.DecBinary()
		_ = yym1108
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1107), d)
		}
	}
	for {
		yyj1104++
		if yyhl1104 {
			yyb1104 = yyj1104 > l
		} else {
			yyb1104 = r.CheckBreak()
		}
		if yyb1104 {
			break
		}
		z.DecStructFieldNotFound(yyj1104-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 {
		yym1109 := z.EncBinary()
		_ = yym1109
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1110 := !z.EncBinary()
			yy2arr1110 := z.EncBasicHandle().StructToArray
			var yyq1110 [3]bool
			_, _, _ = yysep1110, yyq1110, yy2arr1110
			const yyr1110 bool = false
			yyq1110[2] = len(x.Values) != 0
			if yyr1110 || yy2arr1110 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1110 int = 2
				for _, b := range yyq1110 {
					if b {
						yynn1110++
					}
				}
				r.EncodeMapStart(yynn1110)
			}
			if yyr1110 || yy2arr1110 {
				yym1112 := z.EncBinary()
				_ = yym1112
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1113 := z.EncBinary()
				_ = yym1113
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1110 || yy2arr1110 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1110 || yy2arr1110 {
				if yyq1110[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1116 := z.EncBinary()
						_ = yym1116
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1110[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1117 := z.EncBinary()
						_ = yym1117
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1110 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *PodSelectorRequirement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1118 := z.DecBinary()
	_ = yym1118
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1119 := r.ReadMapStart()
			if yyl1119 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1119, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1119 := r.ReadArrayStart()
			if yyl1119 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1119, 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 yys1120Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1120Slc
	var yyhl1120 bool = l >= 0
	for yyj1120 := 0; ; yyj1120++ {
		if yyhl1120 {
			if yyj1120 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1120Slc = r.DecodeBytes(yys1120Slc, true, true)
		yys1120 := string(yys1120Slc)
		switch yys1120 {
		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 {
				yyv1123 := &x.Values
				yym1124 := z.DecBinary()
				_ = yym1124
				if false {
				} else {
					z.F.DecSliceStringX(yyv1123, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1120)
		} // end switch yys1120
	} // end for yyj1120
	if !yyhl1120 {
		r.ReadEnd()
	}
}

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

func (x PodSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1130 := z.EncBinary()
	_ = yym1130
	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
	yym1131 := z.DecBinary()
	_ = yym1131
	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 _, yyv1132 := range v {
		yy1133 := &yyv1132
		yy1133.CodecEncodeSelf(e)
	}
	r.EncodeEnd()
}

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

	yyv1134 := *v
	yyh1134, yyl1134 := z.DecSliceHelperStart()

	var yyrr1134, yyrl1134 int
	var yyc1134, yyrt1134 bool
	_, _, _ = yyc1134, yyrt1134, yyrl1134
	yyrr1134 = yyl1134

	if yyv1134 == nil {
		if yyrl1134, yyrt1134 = z.DecInferLen(yyl1134, z.DecBasicHandle().MaxInitLen, 336); yyrt1134 {
			yyrr1134 = yyrl1134
		}
		yyv1134 = make([]HorizontalPodAutoscaler, yyrl1134)
		yyc1134 = true
	}

	if yyl1134 == 0 {
		if len(yyv1134) != 0 {
			yyv1134 = yyv1134[:0]
			yyc1134 = true
		}
	} else if yyl1134 > 0 {

		if yyl1134 > cap(yyv1134) {
			yyrl1134, yyrt1134 = z.DecInferLen(yyl1134, z.DecBasicHandle().MaxInitLen, 336)
			yyv1134 = make([]HorizontalPodAutoscaler, yyrl1134)
			yyc1134 = true

			yyrr1134 = len(yyv1134)
		} else if yyl1134 != len(yyv1134) {
			yyv1134 = yyv1134[:yyl1134]
			yyc1134 = true
		}
		yyj1134 := 0
		for ; yyj1134 < yyrr1134; yyj1134++ {
			if r.TryDecodeAsNil() {
				yyv1134[yyj1134] = HorizontalPodAutoscaler{}
			} else {
				yyv1135 := &yyv1134[yyj1134]
				yyv1135.CodecDecodeSelf(d)
			}

		}
		if yyrt1134 {
			for ; yyj1134 < yyl1134; yyj1134++ {
				yyv1134 = append(yyv1134, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1134[yyj1134] = HorizontalPodAutoscaler{}
				} else {
					yyv1136 := &yyv1134[yyj1134]
					yyv1136.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1134 := 0; !r.CheckBreak(); yyj1134++ {
			if yyj1134 >= len(yyv1134) {
				yyv1134 = append(yyv1134, HorizontalPodAutoscaler{}) // var yyz1134 HorizontalPodAutoscaler
				yyc1134 = true
			}

			if yyj1134 < len(yyv1134) {
				if r.TryDecodeAsNil() {
					yyv1134[yyj1134] = HorizontalPodAutoscaler{}
				} else {
					yyv1137 := &yyv1134[yyj1134]
					yyv1137.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1134.End()
	}
	if yyc1134 {
		*v = yyv1134
	}

}

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

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

	yyv1140 := *v
	yyh1140, yyl1140 := z.DecSliceHelperStart()

	var yyrr1140, yyrl1140 int
	var yyc1140, yyrt1140 bool
	_, _, _ = yyc1140, yyrt1140, yyrl1140
	yyrr1140 = yyl1140

	if yyv1140 == nil {
		if yyrl1140, yyrt1140 = z.DecInferLen(yyl1140, z.DecBasicHandle().MaxInitLen, 32); yyrt1140 {
			yyrr1140 = yyrl1140
		}
		yyv1140 = make([]APIVersion, yyrl1140)
		yyc1140 = true
	}

	if yyl1140 == 0 {
		if len(yyv1140) != 0 {
			yyv1140 = yyv1140[:0]
			yyc1140 = true
		}
	} else if yyl1140 > 0 {

		if yyl1140 > cap(yyv1140) {
			yyrl1140, yyrt1140 = z.DecInferLen(yyl1140, z.DecBasicHandle().MaxInitLen, 32)
			yyv1140 = make([]APIVersion, yyrl1140)
			yyc1140 = true

			yyrr1140 = len(yyv1140)
		} else if yyl1140 != len(yyv1140) {
			yyv1140 = yyv1140[:yyl1140]
			yyc1140 = true
		}
		yyj1140 := 0
		for ; yyj1140 < yyrr1140; yyj1140++ {
			if r.TryDecodeAsNil() {
				yyv1140[yyj1140] = APIVersion{}
			} else {
				yyv1141 := &yyv1140[yyj1140]
				yyv1141.CodecDecodeSelf(d)
			}

		}
		if yyrt1140 {
			for ; yyj1140 < yyl1140; yyj1140++ {
				yyv1140 = append(yyv1140, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1140[yyj1140] = APIVersion{}
				} else {
					yyv1142 := &yyv1140[yyj1140]
					yyv1142.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1140 := 0; !r.CheckBreak(); yyj1140++ {
			if yyj1140 >= len(yyv1140) {
				yyv1140 = append(yyv1140, APIVersion{}) // var yyz1140 APIVersion
				yyc1140 = true
			}

			if yyj1140 < len(yyv1140) {
				if r.TryDecodeAsNil() {
					yyv1140[yyj1140] = APIVersion{}
				} else {
					yyv1143 := &yyv1140[yyj1140]
					yyv1143.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1140.End()
	}
	if yyc1140 {
		*v = yyv1140
	}

}

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

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

	yyv1146 := *v
	yyh1146, yyl1146 := z.DecSliceHelperStart()

	var yyrr1146, yyrl1146 int
	var yyc1146, yyrt1146 bool
	_, _, _ = yyc1146, yyrt1146, yyrl1146
	yyrr1146 = yyl1146

	if yyv1146 == nil {
		if yyrl1146, yyrt1146 = z.DecInferLen(yyl1146, z.DecBasicHandle().MaxInitLen, 232); yyrt1146 {
			yyrr1146 = yyrl1146
		}
		yyv1146 = make([]ThirdPartyResource, yyrl1146)
		yyc1146 = true
	}

	if yyl1146 == 0 {
		if len(yyv1146) != 0 {
			yyv1146 = yyv1146[:0]
			yyc1146 = true
		}
	} else if yyl1146 > 0 {

		if yyl1146 > cap(yyv1146) {
			yyrl1146, yyrt1146 = z.DecInferLen(yyl1146, z.DecBasicHandle().MaxInitLen, 232)
			yyv1146 = make([]ThirdPartyResource, yyrl1146)
			yyc1146 = true

			yyrr1146 = len(yyv1146)
		} else if yyl1146 != len(yyv1146) {
			yyv1146 = yyv1146[:yyl1146]
			yyc1146 = true
		}
		yyj1146 := 0
		for ; yyj1146 < yyrr1146; yyj1146++ {
			if r.TryDecodeAsNil() {
				yyv1146[yyj1146] = ThirdPartyResource{}
			} else {
				yyv1147 := &yyv1146[yyj1146]
				yyv1147.CodecDecodeSelf(d)
			}

		}
		if yyrt1146 {
			for ; yyj1146 < yyl1146; yyj1146++ {
				yyv1146 = append(yyv1146, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1146[yyj1146] = ThirdPartyResource{}
				} else {
					yyv1148 := &yyv1146[yyj1146]
					yyv1148.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1146 := 0; !r.CheckBreak(); yyj1146++ {
			if yyj1146 >= len(yyv1146) {
				yyv1146 = append(yyv1146, ThirdPartyResource{}) // var yyz1146 ThirdPartyResource
				yyc1146 = true
			}

			if yyj1146 < len(yyv1146) {
				if r.TryDecodeAsNil() {
					yyv1146[yyj1146] = ThirdPartyResource{}
				} else {
					yyv1149 := &yyv1146[yyj1146]
					yyv1149.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1146.End()
	}
	if yyc1146 {
		*v = yyv1146
	}

}

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

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

	yyv1152 := *v
	yyh1152, yyl1152 := z.DecSliceHelperStart()

	var yyrr1152, yyrl1152 int
	var yyc1152, yyrt1152 bool
	_, _, _ = yyc1152, yyrt1152, yyrl1152
	yyrr1152 = yyl1152

	if yyv1152 == nil {
		if yyrl1152, yyrt1152 = z.DecInferLen(yyl1152, z.DecBasicHandle().MaxInitLen, 264); yyrt1152 {
			yyrr1152 = yyrl1152
		}
		yyv1152 = make([]Deployment, yyrl1152)
		yyc1152 = true
	}

	if yyl1152 == 0 {
		if len(yyv1152) != 0 {
			yyv1152 = yyv1152[:0]
			yyc1152 = true
		}
	} else if yyl1152 > 0 {

		if yyl1152 > cap(yyv1152) {
			yyrl1152, yyrt1152 = z.DecInferLen(yyl1152, z.DecBasicHandle().MaxInitLen, 264)
			yyv1152 = make([]Deployment, yyrl1152)
			yyc1152 = true

			yyrr1152 = len(yyv1152)
		} else if yyl1152 != len(yyv1152) {
			yyv1152 = yyv1152[:yyl1152]
			yyc1152 = true
		}
		yyj1152 := 0
		for ; yyj1152 < yyrr1152; yyj1152++ {
			if r.TryDecodeAsNil() {
				yyv1152[yyj1152] = Deployment{}
			} else {
				yyv1153 := &yyv1152[yyj1152]
				yyv1153.CodecDecodeSelf(d)
			}

		}
		if yyrt1152 {
			for ; yyj1152 < yyl1152; yyj1152++ {
				yyv1152 = append(yyv1152, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1152[yyj1152] = Deployment{}
				} else {
					yyv1154 := &yyv1152[yyj1152]
					yyv1154.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1152 := 0; !r.CheckBreak(); yyj1152++ {
			if yyj1152 >= len(yyv1152) {
				yyv1152 = append(yyv1152, Deployment{}) // var yyz1152 Deployment
				yyc1152 = true
			}

			if yyj1152 < len(yyv1152) {
				if r.TryDecodeAsNil() {
					yyv1152[yyj1152] = Deployment{}
				} else {
					yyv1155 := &yyv1152[yyj1152]
					yyv1155.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1152.End()
	}
	if yyc1152 {
		*v = yyv1152
	}

}

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

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

	yyv1158 := *v
	yyh1158, yyl1158 := z.DecSliceHelperStart()

	var yyrr1158, yyrl1158 int
	var yyc1158, yyrt1158 bool
	_, _, _ = yyc1158, yyrt1158, yyrl1158
	yyrr1158 = yyl1158

	if yyv1158 == nil {
		if yyrl1158, yyrt1158 = z.DecInferLen(yyl1158, z.DecBasicHandle().MaxInitLen, 232); yyrt1158 {
			yyrr1158 = yyrl1158
		}
		yyv1158 = make([]DaemonSet, yyrl1158)
		yyc1158 = true
	}

	if yyl1158 == 0 {
		if len(yyv1158) != 0 {
			yyv1158 = yyv1158[:0]
			yyc1158 = true
		}
	} else if yyl1158 > 0 {

		if yyl1158 > cap(yyv1158) {
			yyrl1158, yyrt1158 = z.DecInferLen(yyl1158, z.DecBasicHandle().MaxInitLen, 232)
			yyv1158 = make([]DaemonSet, yyrl1158)
			yyc1158 = true

			yyrr1158 = len(yyv1158)
		} else if yyl1158 != len(yyv1158) {
			yyv1158 = yyv1158[:yyl1158]
			yyc1158 = true
		}
		yyj1158 := 0
		for ; yyj1158 < yyrr1158; yyj1158++ {
			if r.TryDecodeAsNil() {
				yyv1158[yyj1158] = DaemonSet{}
			} else {
				yyv1159 := &yyv1158[yyj1158]
				yyv1159.CodecDecodeSelf(d)
			}

		}
		if yyrt1158 {
			for ; yyj1158 < yyl1158; yyj1158++ {
				yyv1158 = append(yyv1158, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1158[yyj1158] = DaemonSet{}
				} else {
					yyv1160 := &yyv1158[yyj1158]
					yyv1160.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1158 := 0; !r.CheckBreak(); yyj1158++ {
			if yyj1158 >= len(yyv1158) {
				yyv1158 = append(yyv1158, DaemonSet{}) // var yyz1158 DaemonSet
				yyc1158 = true
			}

			if yyj1158 < len(yyv1158) {
				if r.TryDecodeAsNil() {
					yyv1158[yyj1158] = DaemonSet{}
				} else {
					yyv1161 := &yyv1158[yyj1158]
					yyv1161.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1158.End()
	}
	if yyc1158 {
		*v = yyv1158
	}

}

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

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

	yyv1164 := *v
	yyh1164, yyl1164 := z.DecSliceHelperStart()

	var yyrr1164, yyrl1164 int
	var yyc1164, yyrt1164 bool
	_, _, _ = yyc1164, yyrt1164, yyrl1164
	yyrr1164 = yyl1164

	if yyv1164 == nil {
		if yyrl1164, yyrt1164 = z.DecInferLen(yyl1164, z.DecBasicHandle().MaxInitLen, 216); yyrt1164 {
			yyrr1164 = yyrl1164
		}
		yyv1164 = make([]ThirdPartyResourceData, yyrl1164)
		yyc1164 = true
	}

	if yyl1164 == 0 {
		if len(yyv1164) != 0 {
			yyv1164 = yyv1164[:0]
			yyc1164 = true
		}
	} else if yyl1164 > 0 {

		if yyl1164 > cap(yyv1164) {
			yyrl1164, yyrt1164 = z.DecInferLen(yyl1164, z.DecBasicHandle().MaxInitLen, 216)
			yyv1164 = make([]ThirdPartyResourceData, yyrl1164)
			yyc1164 = true

			yyrr1164 = len(yyv1164)
		} else if yyl1164 != len(yyv1164) {
			yyv1164 = yyv1164[:yyl1164]
			yyc1164 = true
		}
		yyj1164 := 0
		for ; yyj1164 < yyrr1164; yyj1164++ {
			if r.TryDecodeAsNil() {
				yyv1164[yyj1164] = ThirdPartyResourceData{}
			} else {
				yyv1165 := &yyv1164[yyj1164]
				yyv1165.CodecDecodeSelf(d)
			}

		}
		if yyrt1164 {
			for ; yyj1164 < yyl1164; yyj1164++ {
				yyv1164 = append(yyv1164, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1164[yyj1164] = ThirdPartyResourceData{}
				} else {
					yyv1166 := &yyv1164[yyj1164]
					yyv1166.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1164 := 0; !r.CheckBreak(); yyj1164++ {
			if yyj1164 >= len(yyv1164) {
				yyv1164 = append(yyv1164, ThirdPartyResourceData{}) // var yyz1164 ThirdPartyResourceData
				yyc1164 = true
			}

			if yyj1164 < len(yyv1164) {
				if r.TryDecodeAsNil() {
					yyv1164[yyj1164] = ThirdPartyResourceData{}
				} else {
					yyv1167 := &yyv1164[yyj1164]
					yyv1167.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1164.End()
	}
	if yyc1164 {
		*v = yyv1164
	}

}

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

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

	yyv1170 := *v
	yyh1170, yyl1170 := z.DecSliceHelperStart()

	var yyrr1170, yyrl1170 int
	var yyc1170, yyrt1170 bool
	_, _, _ = yyc1170, yyrt1170, yyrl1170
	yyrr1170 = yyl1170

	if yyv1170 == nil {
		if yyrl1170, yyrt1170 = z.DecInferLen(yyl1170, z.DecBasicHandle().MaxInitLen, 632); yyrt1170 {
			yyrr1170 = yyrl1170
		}
		yyv1170 = make([]Job, yyrl1170)
		yyc1170 = true
	}

	if yyl1170 == 0 {
		if len(yyv1170) != 0 {
			yyv1170 = yyv1170[:0]
			yyc1170 = true
		}
	} else if yyl1170 > 0 {

		if yyl1170 > cap(yyv1170) {
			yyrl1170, yyrt1170 = z.DecInferLen(yyl1170, z.DecBasicHandle().MaxInitLen, 632)
			yyv1170 = make([]Job, yyrl1170)
			yyc1170 = true

			yyrr1170 = len(yyv1170)
		} else if yyl1170 != len(yyv1170) {
			yyv1170 = yyv1170[:yyl1170]
			yyc1170 = true
		}
		yyj1170 := 0
		for ; yyj1170 < yyrr1170; yyj1170++ {
			if r.TryDecodeAsNil() {
				yyv1170[yyj1170] = Job{}
			} else {
				yyv1171 := &yyv1170[yyj1170]
				yyv1171.CodecDecodeSelf(d)
			}

		}
		if yyrt1170 {
			for ; yyj1170 < yyl1170; yyj1170++ {
				yyv1170 = append(yyv1170, Job{})
				if r.TryDecodeAsNil() {
					yyv1170[yyj1170] = Job{}
				} else {
					yyv1172 := &yyv1170[yyj1170]
					yyv1172.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1170 := 0; !r.CheckBreak(); yyj1170++ {
			if yyj1170 >= len(yyv1170) {
				yyv1170 = append(yyv1170, Job{}) // var yyz1170 Job
				yyc1170 = true
			}

			if yyj1170 < len(yyv1170) {
				if r.TryDecodeAsNil() {
					yyv1170[yyj1170] = Job{}
				} else {
					yyv1173 := &yyv1170[yyj1170]
					yyv1173.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1170.End()
	}
	if yyc1170 {
		*v = yyv1170
	}

}

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

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

	yyv1176 := *v
	yyh1176, yyl1176 := z.DecSliceHelperStart()

	var yyrr1176, yyrl1176 int
	var yyc1176, yyrt1176 bool
	_, _, _ = yyc1176, yyrt1176, yyrl1176
	yyrr1176 = yyl1176

	if yyv1176 == nil {
		if yyrl1176, yyrt1176 = z.DecInferLen(yyl1176, z.DecBasicHandle().MaxInitLen, 112); yyrt1176 {
			yyrr1176 = yyrl1176
		}
		yyv1176 = make([]JobCondition, yyrl1176)
		yyc1176 = true
	}

	if yyl1176 == 0 {
		if len(yyv1176) != 0 {
			yyv1176 = yyv1176[:0]
			yyc1176 = true
		}
	} else if yyl1176 > 0 {

		if yyl1176 > cap(yyv1176) {
			yyrl1176, yyrt1176 = z.DecInferLen(yyl1176, z.DecBasicHandle().MaxInitLen, 112)
			yyv1176 = make([]JobCondition, yyrl1176)
			yyc1176 = true

			yyrr1176 = len(yyv1176)
		} else if yyl1176 != len(yyv1176) {
			yyv1176 = yyv1176[:yyl1176]
			yyc1176 = true
		}
		yyj1176 := 0
		for ; yyj1176 < yyrr1176; yyj1176++ {
			if r.TryDecodeAsNil() {
				yyv1176[yyj1176] = JobCondition{}
			} else {
				yyv1177 := &yyv1176[yyj1176]
				yyv1177.CodecDecodeSelf(d)
			}

		}
		if yyrt1176 {
			for ; yyj1176 < yyl1176; yyj1176++ {
				yyv1176 = append(yyv1176, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1176[yyj1176] = JobCondition{}
				} else {
					yyv1178 := &yyv1176[yyj1176]
					yyv1178.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1176 := 0; !r.CheckBreak(); yyj1176++ {
			if yyj1176 >= len(yyv1176) {
				yyv1176 = append(yyv1176, JobCondition{}) // var yyz1176 JobCondition
				yyc1176 = true
			}

			if yyj1176 < len(yyv1176) {
				if r.TryDecodeAsNil() {
					yyv1176[yyj1176] = JobCondition{}
				} else {
					yyv1179 := &yyv1176[yyj1176]
					yyv1179.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1176.End()
	}
	if yyc1176 {
		*v = yyv1176
	}

}

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

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

	yyv1182 := *v
	yyh1182, yyl1182 := z.DecSliceHelperStart()

	var yyrr1182, yyrl1182 int
	var yyc1182, yyrt1182 bool
	_, _, _ = yyc1182, yyrt1182, yyrl1182
	yyrr1182 = yyl1182

	if yyv1182 == nil {
		if yyrl1182, yyrt1182 = z.DecInferLen(yyl1182, z.DecBasicHandle().MaxInitLen, 248); yyrt1182 {
			yyrr1182 = yyrl1182
		}
		yyv1182 = make([]Ingress, yyrl1182)
		yyc1182 = true
	}

	if yyl1182 == 0 {
		if len(yyv1182) != 0 {
			yyv1182 = yyv1182[:0]
			yyc1182 = true
		}
	} else if yyl1182 > 0 {

		if yyl1182 > cap(yyv1182) {
			yyrl1182, yyrt1182 = z.DecInferLen(yyl1182, z.DecBasicHandle().MaxInitLen, 248)
			yyv1182 = make([]Ingress, yyrl1182)
			yyc1182 = true

			yyrr1182 = len(yyv1182)
		} else if yyl1182 != len(yyv1182) {
			yyv1182 = yyv1182[:yyl1182]
			yyc1182 = true
		}
		yyj1182 := 0
		for ; yyj1182 < yyrr1182; yyj1182++ {
			if r.TryDecodeAsNil() {
				yyv1182[yyj1182] = Ingress{}
			} else {
				yyv1183 := &yyv1182[yyj1182]
				yyv1183.CodecDecodeSelf(d)
			}

		}
		if yyrt1182 {
			for ; yyj1182 < yyl1182; yyj1182++ {
				yyv1182 = append(yyv1182, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1182[yyj1182] = Ingress{}
				} else {
					yyv1184 := &yyv1182[yyj1182]
					yyv1184.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1182 := 0; !r.CheckBreak(); yyj1182++ {
			if yyj1182 >= len(yyv1182) {
				yyv1182 = append(yyv1182, Ingress{}) // var yyz1182 Ingress
				yyc1182 = true
			}

			if yyj1182 < len(yyv1182) {
				if r.TryDecodeAsNil() {
					yyv1182[yyj1182] = Ingress{}
				} else {
					yyv1185 := &yyv1182[yyj1182]
					yyv1185.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1182.End()
	}
	if yyc1182 {
		*v = yyv1182
	}

}

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

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

	yyv1188 := *v
	yyh1188, yyl1188 := z.DecSliceHelperStart()

	var yyrr1188, yyrl1188 int
	var yyc1188, yyrt1188 bool
	_, _, _ = yyc1188, yyrt1188, yyrl1188
	yyrr1188 = yyl1188

	if yyv1188 == nil {
		if yyrl1188, yyrt1188 = z.DecInferLen(yyl1188, z.DecBasicHandle().MaxInitLen, 24); yyrt1188 {
			yyrr1188 = yyrl1188
		}
		yyv1188 = make([]IngressRule, yyrl1188)
		yyc1188 = true
	}

	if yyl1188 == 0 {
		if len(yyv1188) != 0 {
			yyv1188 = yyv1188[:0]
			yyc1188 = true
		}
	} else if yyl1188 > 0 {

		if yyl1188 > cap(yyv1188) {
			yyrl1188, yyrt1188 = z.DecInferLen(yyl1188, z.DecBasicHandle().MaxInitLen, 24)
			yyv1188 = make([]IngressRule, yyrl1188)
			yyc1188 = true

			yyrr1188 = len(yyv1188)
		} else if yyl1188 != len(yyv1188) {
			yyv1188 = yyv1188[:yyl1188]
			yyc1188 = true
		}
		yyj1188 := 0
		for ; yyj1188 < yyrr1188; yyj1188++ {
			if r.TryDecodeAsNil() {
				yyv1188[yyj1188] = IngressRule{}
			} else {
				yyv1189 := &yyv1188[yyj1188]
				yyv1189.CodecDecodeSelf(d)
			}

		}
		if yyrt1188 {
			for ; yyj1188 < yyl1188; yyj1188++ {
				yyv1188 = append(yyv1188, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1188[yyj1188] = IngressRule{}
				} else {
					yyv1190 := &yyv1188[yyj1188]
					yyv1190.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1188 := 0; !r.CheckBreak(); yyj1188++ {
			if yyj1188 >= len(yyv1188) {
				yyv1188 = append(yyv1188, IngressRule{}) // var yyz1188 IngressRule
				yyc1188 = true
			}

			if yyj1188 < len(yyv1188) {
				if r.TryDecodeAsNil() {
					yyv1188[yyj1188] = IngressRule{}
				} else {
					yyv1191 := &yyv1188[yyj1188]
					yyv1191.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1188.End()
	}
	if yyc1188 {
		*v = yyv1188
	}

}

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

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

	yyv1194 := *v
	yyh1194, yyl1194 := z.DecSliceHelperStart()

	var yyrr1194, yyrl1194 int
	var yyc1194, yyrt1194 bool
	_, _, _ = yyc1194, yyrt1194, yyrl1194
	yyrr1194 = yyl1194

	if yyv1194 == nil {
		if yyrl1194, yyrt1194 = z.DecInferLen(yyl1194, z.DecBasicHandle().MaxInitLen, 64); yyrt1194 {
			yyrr1194 = yyrl1194
		}
		yyv1194 = make([]HTTPIngressPath, yyrl1194)
		yyc1194 = true
	}

	if yyl1194 == 0 {
		if len(yyv1194) != 0 {
			yyv1194 = yyv1194[:0]
			yyc1194 = true
		}
	} else if yyl1194 > 0 {

		if yyl1194 > cap(yyv1194) {
			yyrl1194, yyrt1194 = z.DecInferLen(yyl1194, z.DecBasicHandle().MaxInitLen, 64)
			yyv1194 = make([]HTTPIngressPath, yyrl1194)
			yyc1194 = true

			yyrr1194 = len(yyv1194)
		} else if yyl1194 != len(yyv1194) {
			yyv1194 = yyv1194[:yyl1194]
			yyc1194 = true
		}
		yyj1194 := 0
		for ; yyj1194 < yyrr1194; yyj1194++ {
			if r.TryDecodeAsNil() {
				yyv1194[yyj1194] = HTTPIngressPath{}
			} else {
				yyv1195 := &yyv1194[yyj1194]
				yyv1195.CodecDecodeSelf(d)
			}

		}
		if yyrt1194 {
			for ; yyj1194 < yyl1194; yyj1194++ {
				yyv1194 = append(yyv1194, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1194[yyj1194] = HTTPIngressPath{}
				} else {
					yyv1196 := &yyv1194[yyj1194]
					yyv1196.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1194 := 0; !r.CheckBreak(); yyj1194++ {
			if yyj1194 >= len(yyv1194) {
				yyv1194 = append(yyv1194, HTTPIngressPath{}) // var yyz1194 HTTPIngressPath
				yyc1194 = true
			}

			if yyj1194 < len(yyv1194) {
				if r.TryDecodeAsNil() {
					yyv1194[yyj1194] = HTTPIngressPath{}
				} else {
					yyv1197 := &yyv1194[yyj1194]
					yyv1197.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1194.End()
	}
	if yyc1194 {
		*v = yyv1194
	}

}

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

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

	yyv1200 := *v
	yyh1200, yyl1200 := z.DecSliceHelperStart()

	var yyrr1200, yyrl1200 int
	var yyc1200, yyrt1200 bool
	_, _, _ = yyc1200, yyrt1200, yyrl1200
	yyrr1200 = yyl1200

	if yyv1200 == nil {
		if yyrl1200, yyrt1200 = z.DecInferLen(yyl1200, z.DecBasicHandle().MaxInitLen, 24); yyrt1200 {
			yyrr1200 = yyrl1200
		}
		yyv1200 = make([]NodeUtilization, yyrl1200)
		yyc1200 = true
	}

	if yyl1200 == 0 {
		if len(yyv1200) != 0 {
			yyv1200 = yyv1200[:0]
			yyc1200 = true
		}
	} else if yyl1200 > 0 {

		if yyl1200 > cap(yyv1200) {
			yyrl1200, yyrt1200 = z.DecInferLen(yyl1200, z.DecBasicHandle().MaxInitLen, 24)
			yyv1200 = make([]NodeUtilization, yyrl1200)
			yyc1200 = true

			yyrr1200 = len(yyv1200)
		} else if yyl1200 != len(yyv1200) {
			yyv1200 = yyv1200[:yyl1200]
			yyc1200 = true
		}
		yyj1200 := 0
		for ; yyj1200 < yyrr1200; yyj1200++ {
			if r.TryDecodeAsNil() {
				yyv1200[yyj1200] = NodeUtilization{}
			} else {
				yyv1201 := &yyv1200[yyj1200]
				yyv1201.CodecDecodeSelf(d)
			}

		}
		if yyrt1200 {
			for ; yyj1200 < yyl1200; yyj1200++ {
				yyv1200 = append(yyv1200, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1200[yyj1200] = NodeUtilization{}
				} else {
					yyv1202 := &yyv1200[yyj1200]
					yyv1202.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1200 := 0; !r.CheckBreak(); yyj1200++ {
			if yyj1200 >= len(yyv1200) {
				yyv1200 = append(yyv1200, NodeUtilization{}) // var yyz1200 NodeUtilization
				yyc1200 = true
			}

			if yyj1200 < len(yyv1200) {
				if r.TryDecodeAsNil() {
					yyv1200[yyj1200] = NodeUtilization{}
				} else {
					yyv1203 := &yyv1200[yyj1200]
					yyv1203.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1200.End()
	}
	if yyc1200 {
		*v = yyv1200
	}

}

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

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

	yyv1206 := *v
	yyh1206, yyl1206 := z.DecSliceHelperStart()

	var yyrr1206, yyrl1206 int
	var yyc1206, yyrt1206 bool
	_, _, _ = yyc1206, yyrt1206, yyrl1206
	yyrr1206 = yyl1206

	if yyv1206 == nil {
		if yyrl1206, yyrt1206 = z.DecInferLen(yyl1206, z.DecBasicHandle().MaxInitLen, 232); yyrt1206 {
			yyrr1206 = yyrl1206
		}
		yyv1206 = make([]ClusterAutoscaler, yyrl1206)
		yyc1206 = true
	}

	if yyl1206 == 0 {
		if len(yyv1206) != 0 {
			yyv1206 = yyv1206[:0]
			yyc1206 = true
		}
	} else if yyl1206 > 0 {

		if yyl1206 > cap(yyv1206) {
			yyrl1206, yyrt1206 = z.DecInferLen(yyl1206, z.DecBasicHandle().MaxInitLen, 232)
			yyv1206 = make([]ClusterAutoscaler, yyrl1206)
			yyc1206 = true

			yyrr1206 = len(yyv1206)
		} else if yyl1206 != len(yyv1206) {
			yyv1206 = yyv1206[:yyl1206]
			yyc1206 = true
		}
		yyj1206 := 0
		for ; yyj1206 < yyrr1206; yyj1206++ {
			if r.TryDecodeAsNil() {
				yyv1206[yyj1206] = ClusterAutoscaler{}
			} else {
				yyv1207 := &yyv1206[yyj1206]
				yyv1207.CodecDecodeSelf(d)
			}

		}
		if yyrt1206 {
			for ; yyj1206 < yyl1206; yyj1206++ {
				yyv1206 = append(yyv1206, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1206[yyj1206] = ClusterAutoscaler{}
				} else {
					yyv1208 := &yyv1206[yyj1206]
					yyv1208.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1206 := 0; !r.CheckBreak(); yyj1206++ {
			if yyj1206 >= len(yyv1206) {
				yyv1206 = append(yyv1206, ClusterAutoscaler{}) // var yyz1206 ClusterAutoscaler
				yyc1206 = true
			}

			if yyj1206 < len(yyv1206) {
				if r.TryDecodeAsNil() {
					yyv1206[yyj1206] = ClusterAutoscaler{}
				} else {
					yyv1209 := &yyv1206[yyj1206]
					yyv1209.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1206.End()
	}
	if yyc1206 {
		*v = yyv1206
	}

}

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

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

	yyv1212 := *v
	yyh1212, yyl1212 := z.DecSliceHelperStart()

	var yyrr1212, yyrl1212 int
	var yyc1212, yyrt1212 bool
	_, _, _ = yyc1212, yyrt1212, yyrl1212
	yyrr1212 = yyl1212

	if yyv1212 == nil {
		if yyrl1212, yyrt1212 = z.DecInferLen(yyl1212, z.DecBasicHandle().MaxInitLen, 56); yyrt1212 {
			yyrr1212 = yyrl1212
		}
		yyv1212 = make([]PodSelectorRequirement, yyrl1212)
		yyc1212 = true
	}

	if yyl1212 == 0 {
		if len(yyv1212) != 0 {
			yyv1212 = yyv1212[:0]
			yyc1212 = true
		}
	} else if yyl1212 > 0 {

		if yyl1212 > cap(yyv1212) {
			yyrl1212, yyrt1212 = z.DecInferLen(yyl1212, z.DecBasicHandle().MaxInitLen, 56)
			yyv1212 = make([]PodSelectorRequirement, yyrl1212)
			yyc1212 = true

			yyrr1212 = len(yyv1212)
		} else if yyl1212 != len(yyv1212) {
			yyv1212 = yyv1212[:yyl1212]
			yyc1212 = true
		}
		yyj1212 := 0
		for ; yyj1212 < yyrr1212; yyj1212++ {
			if r.TryDecodeAsNil() {
				yyv1212[yyj1212] = PodSelectorRequirement{}
			} else {
				yyv1213 := &yyv1212[yyj1212]
				yyv1213.CodecDecodeSelf(d)
			}

		}
		if yyrt1212 {
			for ; yyj1212 < yyl1212; yyj1212++ {
				yyv1212 = append(yyv1212, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1212[yyj1212] = PodSelectorRequirement{}
				} else {
					yyv1214 := &yyv1212[yyj1212]
					yyv1214.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1212 := 0; !r.CheckBreak(); yyj1212++ {
			if yyj1212 >= len(yyv1212) {
				yyv1212 = append(yyv1212, PodSelectorRequirement{}) // var yyz1212 PodSelectorRequirement
				yyc1212 = true
			}

			if yyj1212 < len(yyv1212) {
				if r.TryDecodeAsNil() {
					yyv1212[yyj1212] = PodSelectorRequirement{}
				} else {
					yyv1215 := &yyv1212[yyj1212]
					yyv1215.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1212.End()
	}
	if yyc1212 {
		*v = yyv1212
	}

}