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[3] = true
			yyq392[4] = x.UniqueLabelKey != nil
			if yyr392 || yy2arr392 {
				r.EncodeArrayStart(5)
			} else {
				var yynn392 int = 1
				for _, b := range yyq392 {
					if b {
						yynn392++
					}
				}
				r.EncodeMapStart(yynn392)
			}
			if yyr392 || yy2arr392 {
				if yyq392[0] {
					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 {
				yy402 := &x.Template
				yy402.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy403 := &x.Template
				yy403.CodecEncodeSelf(e)
			}
			if yyr392 || yy2arr392 {
				if yyq392[3] {
					yy405 := &x.Strategy
					yy405.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[3] {
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					yy406 := &x.Strategy
					yy406.CodecEncodeSelf(e)
				}
			}
			if yyr392 || yy2arr392 {
				if yyq392[4] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy408 := *x.UniqueLabelKey
						yym409 := z.EncBinary()
						_ = yym409
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy408))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq392[4] {
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy410 := *x.UniqueLabelKey
						yym411 := z.EncBinary()
						_ = yym411
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy410))
						}
					}
				}
			}
			if yysep392 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj423 int
	var yyb423 bool
	var yyhl423 bool = l >= 0
	yyj423++
	if yyhl423 {
		yyb423 = yyj423 > l
	} else {
		yyb423 = r.CheckBreak()
	}
	if yyb423 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int)
		}
		yym425 := z.DecBinary()
		_ = yym425
		if false {
		} else {
			*((*int)(x.Replicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj423++
	if yyhl423 {
		yyb423 = yyj423 > l
	} else {
		yyb423 = r.CheckBreak()
	}
	if yyb423 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv426 := &x.Selector
		yym427 := z.DecBinary()
		_ = yym427
		if false {
		} else {
			z.F.DecMapStringStringX(yyv426, false, d)
		}
	}
	yyj423++
	if yyhl423 {
		yyb423 = yyj423 > l
	} else {
		yyb423 = r.CheckBreak()
	}
	if yyb423 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv428 := &x.Template
		yyv428.CodecDecodeSelf(d)
	}
	yyj423++
	if yyhl423 {
		yyb423 = yyj423 > l
	} else {
		yyb423 = r.CheckBreak()
	}
	if yyb423 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv429 := &x.Strategy
		yyv429.CodecDecodeSelf(d)
	}
	yyj423++
	if yyhl423 {
		yyb423 = yyj423 > l
	} else {
		yyb423 = r.CheckBreak()
	}
	if yyb423 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym431 := z.DecBinary()
		_ = yym431
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj423++
		if yyhl423 {
			yyb423 = yyj423 > l
		} else {
			yyb423 = r.CheckBreak()
		}
		if yyb423 {
			break
		}
		z.DecStructFieldNotFound(yyj423-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 {
		yym432 := z.EncBinary()
		_ = yym432
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep433 := !z.EncBinary()
			yy2arr433 := z.EncBasicHandle().StructToArray
			var yyq433 [2]bool
			_, _, _ = yysep433, yyq433, yy2arr433
			const yyr433 bool = false
			yyq433[0] = x.Type != ""
			yyq433[1] = x.RollingUpdate != nil
			if yyr433 || yy2arr433 {
				r.EncodeArrayStart(2)
			} else {
				var yynn433 int = 0
				for _, b := range yyq433 {
					if b {
						yynn433++
					}
				}
				r.EncodeMapStart(yynn433)
			}
			if yyr433 || yy2arr433 {
				if yyq433[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq433[0] {
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr433 || yy2arr433 {
				if yyq433[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq433[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yysep433 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym444 := z.EncBinary()
	_ = yym444
	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
	yym445 := z.DecBinary()
	_ = yym445
	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 {
		yym446 := z.EncBinary()
		_ = yym446
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep447 := !z.EncBinary()
			yy2arr447 := z.EncBasicHandle().StructToArray
			var yyq447 [3]bool
			_, _, _ = yysep447, yyq447, yy2arr447
			const yyr447 bool = false
			yyq447[0] = x.MaxUnavailable != nil
			yyq447[1] = x.MaxSurge != nil
			yyq447[2] = x.MinReadySeconds != 0
			if yyr447 || yy2arr447 {
				r.EncodeArrayStart(3)
			} else {
				var yynn447 int = 0
				for _, b := range yyq447 {
					if b {
						yynn447++
					}
				}
				r.EncodeMapStart(yynn447)
			}
			if yyr447 || yy2arr447 {
				if yyq447[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym449 := z.EncBinary()
						_ = yym449
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym449 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq447[0] {
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym450 := z.EncBinary()
						_ = yym450
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym450 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr447 || yy2arr447 {
				if yyq447[1] {
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym452 := z.EncBinary()
						_ = yym452
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym452 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq447[1] {
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym453 := z.EncBinary()
						_ = yym453
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym453 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				}
			}
			if yyr447 || yy2arr447 {
				if yyq447[2] {
					yym455 := z.EncBinary()
					_ = yym455
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq447[2] {
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					yym456 := z.EncBinary()
					_ = yym456
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yysep447 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym457 := z.DecBinary()
	_ = yym457
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl458 := r.ReadMapStart()
			if yyl458 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl458, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl458 := r.ReadArrayStart()
			if yyl458 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl458, 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 yys459Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys459Slc
	var yyhl459 bool = l >= 0
	for yyj459 := 0; ; yyj459++ {
		if yyhl459 {
			if yyj459 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys459Slc = r.DecodeBytes(yys459Slc, true, true)
		yys459 := string(yys459Slc)
		switch yys459 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg6_util.IntOrString)
				}
				yym461 := z.DecBinary()
				_ = yym461
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym461 && 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)
				}
				yym463 := z.DecBinary()
				_ = yym463
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
				} else if !yym463 && 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, yys459)
		} // end switch yys459
	} // end for yyj459
	if !yyhl459 {
		r.ReadEnd()
	}
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj465 int
	var yyb465 bool
	var yyhl465 bool = l >= 0
	yyj465++
	if yyhl465 {
		yyb465 = yyj465 > l
	} else {
		yyb465 = r.CheckBreak()
	}
	if yyb465 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_util.IntOrString)
		}
		yym467 := z.DecBinary()
		_ = yym467
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym467 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj465++
	if yyhl465 {
		yyb465 = yyj465 > l
	} else {
		yyb465 = r.CheckBreak()
	}
	if yyb465 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg6_util.IntOrString)
		}
		yym469 := z.DecBinary()
		_ = yym469
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym469 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	yyj465++
	if yyhl465 {
		yyb465 = yyj465 > l
	} else {
		yyb465 = r.CheckBreak()
	}
	if yyb465 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj465++
		if yyhl465 {
			yyb465 = yyj465 > l
		} else {
			yyb465 = r.CheckBreak()
		}
		if yyb465 {
			break
		}
		z.DecStructFieldNotFound(yyj465-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 {
		yym471 := z.EncBinary()
		_ = yym471
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep472 := !z.EncBinary()
			yy2arr472 := z.EncBasicHandle().StructToArray
			var yyq472 [2]bool
			_, _, _ = yysep472, yyq472, yy2arr472
			const yyr472 bool = false
			yyq472[0] = x.Replicas != 0
			yyq472[1] = x.UpdatedReplicas != 0
			if yyr472 || yy2arr472 {
				r.EncodeArrayStart(2)
			} else {
				var yynn472 int = 0
				for _, b := range yyq472 {
					if b {
						yynn472++
					}
				}
				r.EncodeMapStart(yynn472)
			}
			if yyr472 || yy2arr472 {
				if yyq472[0] {
					yym474 := z.EncBinary()
					_ = yym474
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq472[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym475 := z.EncBinary()
					_ = yym475
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr472 || yy2arr472 {
				if yyq472[1] {
					yym477 := z.EncBinary()
					_ = yym477
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq472[1] {
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					yym478 := z.EncBinary()
					_ = yym478
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yysep472 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj484 int
	var yyb484 bool
	var yyhl484 bool = l >= 0
	yyj484++
	if yyhl484 {
		yyb484 = yyj484 > l
	} else {
		yyb484 = r.CheckBreak()
	}
	if yyb484 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj484++
	if yyhl484 {
		yyb484 = yyj484 > l
	} else {
		yyb484 = r.CheckBreak()
	}
	if yyb484 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj484++
		if yyhl484 {
			yyb484 = yyj484 > l
		} else {
			yyb484 = r.CheckBreak()
		}
		if yyb484 {
			break
		}
		z.DecStructFieldNotFound(yyj484-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 {
		yym487 := z.EncBinary()
		_ = yym487
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep488 := !z.EncBinary()
			yy2arr488 := z.EncBasicHandle().StructToArray
			var yyq488 [4]bool
			_, _, _ = yysep488, yyq488, yy2arr488
			const yyr488 bool = false
			yyq488[0] = x.Kind != ""
			yyq488[1] = x.APIVersion != ""
			yyq488[2] = true
			if yyr488 || yy2arr488 {
				r.EncodeArrayStart(4)
			} else {
				var yynn488 int = 1
				for _, b := range yyq488 {
					if b {
						yynn488++
					}
				}
				r.EncodeMapStart(yynn488)
			}
			if yyr488 || yy2arr488 {
				if yyq488[0] {
					yym490 := z.EncBinary()
					_ = yym490
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq488[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym491 := z.EncBinary()
					_ = yym491
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr488 || yy2arr488 {
				if yyq488[1] {
					yym493 := z.EncBinary()
					_ = yym493
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq488[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym494 := z.EncBinary()
					_ = yym494
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr488 || yy2arr488 {
				if yyq488[2] {
					yy496 := &x.ListMeta
					yym497 := z.EncBinary()
					_ = yym497
					if false {
					} else if z.HasExtensions() && z.EncExt(yy496) {
					} else {
						z.EncFallback(yy496)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq488[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy498 := &x.ListMeta
					yym499 := z.EncBinary()
					_ = yym499
					if false {
					} else if z.HasExtensions() && z.EncExt(yy498) {
					} else {
						z.EncFallback(yy498)
					}
				}
			}
			if yyr488 || yy2arr488 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym501 := z.EncBinary()
					_ = yym501
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym502 := z.EncBinary()
					_ = yym502
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yysep488 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj512 int
	var yyb512 bool
	var yyhl512 bool = l >= 0
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv515 := &x.ListMeta
		yym516 := z.DecBinary()
		_ = yym516
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv515) {
		} else {
			z.DecFallback(yyv515, false)
		}
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv517 := &x.Items
		yym518 := z.DecBinary()
		_ = yym518
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv517), d)
		}
	}
	for {
		yyj512++
		if yyhl512 {
			yyb512 = yyj512 > l
		} else {
			yyb512 = r.CheckBreak()
		}
		if yyb512 {
			break
		}
		z.DecStructFieldNotFound(yyj512-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 {
		yym519 := z.EncBinary()
		_ = yym519
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep520 := !z.EncBinary()
			yy2arr520 := z.EncBasicHandle().StructToArray
			var yyq520 [2]bool
			_, _, _ = yysep520, yyq520, yy2arr520
			const yyr520 bool = false
			yyq520[0] = len(x.Selector) != 0
			yyq520[1] = x.Template != nil
			if yyr520 || yy2arr520 {
				r.EncodeArrayStart(2)
			} else {
				var yynn520 int = 0
				for _, b := range yyq520 {
					if b {
						yynn520++
					}
				}
				r.EncodeMapStart(yynn520)
			}
			if yyr520 || yy2arr520 {
				if yyq520[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym522 := z.EncBinary()
						_ = yym522
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq520[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym523 := z.EncBinary()
						_ = yym523
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr520 || yy2arr520 {
				if yyq520[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq520[1] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yysep520 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym525 := z.DecBinary()
	_ = yym525
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl526 := r.ReadMapStart()
			if yyl526 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl526, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl526 := r.ReadArrayStart()
			if yyl526 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl526, 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 yys527Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys527Slc
	var yyhl527 bool = l >= 0
	for yyj527 := 0; ; yyj527++ {
		if yyhl527 {
			if yyj527 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys527Slc = r.DecodeBytes(yys527Slc, true, true)
		yys527 := string(yys527Slc)
		switch yys527 {
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv528 := &x.Selector
				yym529 := z.DecBinary()
				_ = yym529
				if false {
				} else {
					z.F.DecMapStringStringX(yyv528, 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, yys527)
		} // end switch yys527
	} // end for yyj527
	if !yyhl527 {
		r.ReadEnd()
	}
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj531 int
	var yyb531 bool
	var yyhl531 bool = l >= 0
	yyj531++
	if yyhl531 {
		yyb531 = yyj531 > l
	} else {
		yyb531 = r.CheckBreak()
	}
	if yyb531 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv532 := &x.Selector
		yym533 := z.DecBinary()
		_ = yym533
		if false {
		} else {
			z.F.DecMapStringStringX(yyv532, false, d)
		}
	}
	yyj531++
	if yyhl531 {
		yyb531 = yyj531 > l
	} else {
		yyb531 = r.CheckBreak()
	}
	if yyb531 {
		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 {
		yyj531++
		if yyhl531 {
			yyb531 = yyj531 > l
		} else {
			yyb531 = r.CheckBreak()
		}
		if yyb531 {
			break
		}
		z.DecStructFieldNotFound(yyj531-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 {
		yym535 := z.EncBinary()
		_ = yym535
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep536 := !z.EncBinary()
			yy2arr536 := z.EncBasicHandle().StructToArray
			var yyq536 [3]bool
			_, _, _ = yysep536, yyq536, yy2arr536
			const yyr536 bool = false
			if yyr536 || yy2arr536 {
				r.EncodeArrayStart(3)
			} else {
				var yynn536 int = 3
				for _, b := range yyq536 {
					if b {
						yynn536++
					}
				}
				r.EncodeMapStart(yynn536)
			}
			if yyr536 || yy2arr536 {
				yym538 := z.EncBinary()
				_ = yym538
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym539 := z.EncBinary()
				_ = yym539
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr536 || yy2arr536 {
				yym541 := z.EncBinary()
				_ = yym541
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym542 := z.EncBinary()
				_ = yym542
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr536 || yy2arr536 {
				yym544 := z.EncBinary()
				_ = yym544
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym545 := z.EncBinary()
				_ = yym545
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep536 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj552 int
	var yyb552 bool
	var yyhl552 bool = l >= 0
	yyj552++
	if yyhl552 {
		yyb552 = yyj552 > l
	} else {
		yyb552 = r.CheckBreak()
	}
	if yyb552 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj552++
	if yyhl552 {
		yyb552 = yyj552 > l
	} else {
		yyb552 = r.CheckBreak()
	}
	if yyb552 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj552++
	if yyhl552 {
		yyb552 = yyj552 > l
	} else {
		yyb552 = r.CheckBreak()
	}
	if yyb552 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj552++
		if yyhl552 {
			yyb552 = yyj552 > l
		} else {
			yyb552 = r.CheckBreak()
		}
		if yyb552 {
			break
		}
		z.DecStructFieldNotFound(yyj552-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 {
		yym556 := z.EncBinary()
		_ = yym556
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep557 := !z.EncBinary()
			yy2arr557 := z.EncBasicHandle().StructToArray
			var yyq557 [5]bool
			_, _, _ = yysep557, yyq557, yy2arr557
			const yyr557 bool = false
			yyq557[0] = x.Kind != ""
			yyq557[1] = x.APIVersion != ""
			yyq557[2] = true
			yyq557[3] = true
			yyq557[4] = true
			if yyr557 || yy2arr557 {
				r.EncodeArrayStart(5)
			} else {
				var yynn557 int = 0
				for _, b := range yyq557 {
					if b {
						yynn557++
					}
				}
				r.EncodeMapStart(yynn557)
			}
			if yyr557 || yy2arr557 {
				if yyq557[0] {
					yym559 := z.EncBinary()
					_ = yym559
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq557[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym560 := z.EncBinary()
					_ = yym560
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr557 || yy2arr557 {
				if yyq557[1] {
					yym562 := z.EncBinary()
					_ = yym562
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq557[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym563 := z.EncBinary()
					_ = yym563
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr557 || yy2arr557 {
				if yyq557[2] {
					yy565 := &x.ObjectMeta
					yy565.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq557[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy566 := &x.ObjectMeta
					yy566.CodecEncodeSelf(e)
				}
			}
			if yyr557 || yy2arr557 {
				if yyq557[3] {
					yy568 := &x.Spec
					yy568.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq557[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy569 := &x.Spec
					yy569.CodecEncodeSelf(e)
				}
			}
			if yyr557 || yy2arr557 {
				if yyq557[4] {
					yy571 := &x.Status
					yy571.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq557[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy572 := &x.Status
					yy572.CodecEncodeSelf(e)
				}
			}
			if yysep557 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym573 := z.DecBinary()
	_ = yym573
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl574 := r.ReadMapStart()
			if yyl574 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl574, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl574 := r.ReadArrayStart()
			if yyl574 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl574, 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 yys575Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys575Slc
	var yyhl575 bool = l >= 0
	for yyj575 := 0; ; yyj575++ {
		if yyhl575 {
			if yyj575 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys575Slc = r.DecodeBytes(yys575Slc, true, true)
		yys575 := string(yys575Slc)
		switch yys575 {
		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 {
				yyv578 := &x.ObjectMeta
				yyv578.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv579 := &x.Spec
				yyv579.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv580 := &x.Status
				yyv580.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys575)
		} // end switch yys575
	} // end for yyj575
	if !yyhl575 {
		r.ReadEnd()
	}
}

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj581 int
	var yyb581 bool
	var yyhl581 bool = l >= 0
	yyj581++
	if yyhl581 {
		yyb581 = yyj581 > l
	} else {
		yyb581 = r.CheckBreak()
	}
	if yyb581 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj581++
	if yyhl581 {
		yyb581 = yyj581 > l
	} else {
		yyb581 = r.CheckBreak()
	}
	if yyb581 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj581++
	if yyhl581 {
		yyb581 = yyj581 > l
	} else {
		yyb581 = r.CheckBreak()
	}
	if yyb581 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv584 := &x.ObjectMeta
		yyv584.CodecDecodeSelf(d)
	}
	yyj581++
	if yyhl581 {
		yyb581 = yyj581 > l
	} else {
		yyb581 = r.CheckBreak()
	}
	if yyb581 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv585 := &x.Spec
		yyv585.CodecDecodeSelf(d)
	}
	yyj581++
	if yyhl581 {
		yyb581 = yyj581 > l
	} else {
		yyb581 = r.CheckBreak()
	}
	if yyb581 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv586 := &x.Status
		yyv586.CodecDecodeSelf(d)
	}
	for {
		yyj581++
		if yyhl581 {
			yyb581 = yyj581 > l
		} else {
			yyb581 = r.CheckBreak()
		}
		if yyb581 {
			break
		}
		z.DecStructFieldNotFound(yyj581-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 {
		yym587 := z.EncBinary()
		_ = yym587
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep588 := !z.EncBinary()
			yy2arr588 := z.EncBasicHandle().StructToArray
			var yyq588 [4]bool
			_, _, _ = yysep588, yyq588, yy2arr588
			const yyr588 bool = false
			yyq588[0] = x.Kind != ""
			yyq588[1] = x.APIVersion != ""
			yyq588[2] = true
			if yyr588 || yy2arr588 {
				r.EncodeArrayStart(4)
			} else {
				var yynn588 int = 1
				for _, b := range yyq588 {
					if b {
						yynn588++
					}
				}
				r.EncodeMapStart(yynn588)
			}
			if yyr588 || yy2arr588 {
				if yyq588[0] {
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq588[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym591 := z.EncBinary()
					_ = yym591
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr588 || yy2arr588 {
				if yyq588[1] {
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq588[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym594 := z.EncBinary()
					_ = yym594
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr588 || yy2arr588 {
				if yyq588[2] {
					yy596 := &x.ListMeta
					yym597 := z.EncBinary()
					_ = yym597
					if false {
					} else if z.HasExtensions() && z.EncExt(yy596) {
					} else {
						z.EncFallback(yy596)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq588[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy598 := &x.ListMeta
					yym599 := z.EncBinary()
					_ = yym599
					if false {
					} else if z.HasExtensions() && z.EncExt(yy598) {
					} else {
						z.EncFallback(yy598)
					}
				}
			}
			if yyr588 || yy2arr588 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym601 := z.EncBinary()
					_ = yym601
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym602 := z.EncBinary()
					_ = yym602
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep588 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj612 int
	var yyb612 bool
	var yyhl612 bool = l >= 0
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv615 := &x.ListMeta
		yym616 := z.DecBinary()
		_ = yym616
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv615) {
		} else {
			z.DecFallback(yyv615, false)
		}
	}
	yyj612++
	if yyhl612 {
		yyb612 = yyj612 > l
	} else {
		yyb612 = r.CheckBreak()
	}
	if yyb612 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv617 := &x.Items
		yym618 := z.DecBinary()
		_ = yym618
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv617), d)
		}
	}
	for {
		yyj612++
		if yyhl612 {
			yyb612 = yyj612 > l
		} else {
			yyb612 = r.CheckBreak()
		}
		if yyb612 {
			break
		}
		z.DecStructFieldNotFound(yyj612-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 {
		yym619 := z.EncBinary()
		_ = yym619
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep620 := !z.EncBinary()
			yy2arr620 := z.EncBasicHandle().StructToArray
			var yyq620 [4]bool
			_, _, _ = yysep620, yyq620, yy2arr620
			const yyr620 bool = false
			yyq620[0] = x.Kind != ""
			yyq620[1] = x.APIVersion != ""
			yyq620[2] = true
			if yyr620 || yy2arr620 {
				r.EncodeArrayStart(4)
			} else {
				var yynn620 int = 1
				for _, b := range yyq620 {
					if b {
						yynn620++
					}
				}
				r.EncodeMapStart(yynn620)
			}
			if yyr620 || yy2arr620 {
				if yyq620[0] {
					yym622 := z.EncBinary()
					_ = yym622
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq620[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym623 := z.EncBinary()
					_ = yym623
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr620 || yy2arr620 {
				if yyq620[1] {
					yym625 := z.EncBinary()
					_ = yym625
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq620[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym626 := z.EncBinary()
					_ = yym626
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr620 || yy2arr620 {
				if yyq620[2] {
					yy628 := &x.ListMeta
					yym629 := z.EncBinary()
					_ = yym629
					if false {
					} else if z.HasExtensions() && z.EncExt(yy628) {
					} else {
						z.EncFallback(yy628)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq620[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy630 := &x.ListMeta
					yym631 := z.EncBinary()
					_ = yym631
					if false {
					} else if z.HasExtensions() && z.EncExt(yy630) {
					} else {
						z.EncFallback(yy630)
					}
				}
			}
			if yyr620 || yy2arr620 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym633 := z.EncBinary()
					_ = yym633
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym634 := z.EncBinary()
					_ = yym634
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep620 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj644 int
	var yyb644 bool
	var yyhl644 bool = l >= 0
	yyj644++
	if yyhl644 {
		yyb644 = yyj644 > l
	} else {
		yyb644 = r.CheckBreak()
	}
	if yyb644 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj644++
	if yyhl644 {
		yyb644 = yyj644 > l
	} else {
		yyb644 = r.CheckBreak()
	}
	if yyb644 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj644++
	if yyhl644 {
		yyb644 = yyj644 > l
	} else {
		yyb644 = r.CheckBreak()
	}
	if yyb644 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv647 := &x.ListMeta
		yym648 := z.DecBinary()
		_ = yym648
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv647) {
		} else {
			z.DecFallback(yyv647, false)
		}
	}
	yyj644++
	if yyhl644 {
		yyb644 = yyj644 > l
	} else {
		yyb644 = r.CheckBreak()
	}
	if yyb644 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv649 := &x.Items
		yym650 := z.DecBinary()
		_ = yym650
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv649), d)
		}
	}
	for {
		yyj644++
		if yyhl644 {
			yyb644 = yyj644 > l
		} else {
			yyb644 = r.CheckBreak()
		}
		if yyb644 {
			break
		}
		z.DecStructFieldNotFound(yyj644-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 {
		yym651 := z.EncBinary()
		_ = yym651
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep652 := !z.EncBinary()
			yy2arr652 := z.EncBasicHandle().StructToArray
			var yyq652 [5]bool
			_, _, _ = yysep652, yyq652, yy2arr652
			const yyr652 bool = false
			yyq652[0] = x.Kind != ""
			yyq652[1] = x.APIVersion != ""
			yyq652[2] = true
			yyq652[3] = true
			yyq652[4] = true
			if yyr652 || yy2arr652 {
				r.EncodeArrayStart(5)
			} else {
				var yynn652 int = 0
				for _, b := range yyq652 {
					if b {
						yynn652++
					}
				}
				r.EncodeMapStart(yynn652)
			}
			if yyr652 || yy2arr652 {
				if yyq652[0] {
					yym654 := z.EncBinary()
					_ = yym654
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq652[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym655 := z.EncBinary()
					_ = yym655
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr652 || yy2arr652 {
				if yyq652[1] {
					yym657 := z.EncBinary()
					_ = yym657
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq652[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym658 := z.EncBinary()
					_ = yym658
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr652 || yy2arr652 {
				if yyq652[2] {
					yy660 := &x.ObjectMeta
					yy660.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq652[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy661 := &x.ObjectMeta
					yy661.CodecEncodeSelf(e)
				}
			}
			if yyr652 || yy2arr652 {
				if yyq652[3] {
					yy663 := &x.Spec
					yy663.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq652[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy664 := &x.Spec
					yy664.CodecEncodeSelf(e)
				}
			}
			if yyr652 || yy2arr652 {
				if yyq652[4] {
					yy666 := &x.Status
					yy666.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq652[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy667 := &x.Status
					yy667.CodecEncodeSelf(e)
				}
			}
			if yysep652 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym668 := z.DecBinary()
	_ = yym668
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl669 := r.ReadMapStart()
			if yyl669 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl669, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl669 := r.ReadArrayStart()
			if yyl669 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl669, 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 yys670Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys670Slc
	var yyhl670 bool = l >= 0
	for yyj670 := 0; ; yyj670++ {
		if yyhl670 {
			if yyj670 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys670Slc = r.DecodeBytes(yys670Slc, true, true)
		yys670 := string(yys670Slc)
		switch yys670 {
		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 {
				yyv673 := &x.ObjectMeta
				yyv673.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv674 := &x.Spec
				yyv674.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv675 := &x.Status
				yyv675.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys670)
		} // end switch yys670
	} // end for yyj670
	if !yyhl670 {
		r.ReadEnd()
	}
}

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj676 int
	var yyb676 bool
	var yyhl676 bool = l >= 0
	yyj676++
	if yyhl676 {
		yyb676 = yyj676 > l
	} else {
		yyb676 = r.CheckBreak()
	}
	if yyb676 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj676++
	if yyhl676 {
		yyb676 = yyj676 > l
	} else {
		yyb676 = r.CheckBreak()
	}
	if yyb676 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj676++
	if yyhl676 {
		yyb676 = yyj676 > l
	} else {
		yyb676 = r.CheckBreak()
	}
	if yyb676 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv679 := &x.ObjectMeta
		yyv679.CodecDecodeSelf(d)
	}
	yyj676++
	if yyhl676 {
		yyb676 = yyj676 > l
	} else {
		yyb676 = r.CheckBreak()
	}
	if yyb676 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv680 := &x.Spec
		yyv680.CodecDecodeSelf(d)
	}
	yyj676++
	if yyhl676 {
		yyb676 = yyj676 > l
	} else {
		yyb676 = r.CheckBreak()
	}
	if yyb676 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv681 := &x.Status
		yyv681.CodecDecodeSelf(d)
	}
	for {
		yyj676++
		if yyhl676 {
			yyb676 = yyj676 > l
		} else {
			yyb676 = r.CheckBreak()
		}
		if yyb676 {
			break
		}
		z.DecStructFieldNotFound(yyj676-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 {
		yym682 := z.EncBinary()
		_ = yym682
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep683 := !z.EncBinary()
			yy2arr683 := z.EncBasicHandle().StructToArray
			var yyq683 [4]bool
			_, _, _ = yysep683, yyq683, yy2arr683
			const yyr683 bool = false
			yyq683[0] = x.Kind != ""
			yyq683[1] = x.APIVersion != ""
			yyq683[2] = true
			if yyr683 || yy2arr683 {
				r.EncodeArrayStart(4)
			} else {
				var yynn683 int = 1
				for _, b := range yyq683 {
					if b {
						yynn683++
					}
				}
				r.EncodeMapStart(yynn683)
			}
			if yyr683 || yy2arr683 {
				if yyq683[0] {
					yym685 := z.EncBinary()
					_ = yym685
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq683[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym686 := z.EncBinary()
					_ = yym686
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr683 || yy2arr683 {
				if yyq683[1] {
					yym688 := z.EncBinary()
					_ = yym688
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq683[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym689 := z.EncBinary()
					_ = yym689
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr683 || yy2arr683 {
				if yyq683[2] {
					yy691 := &x.ListMeta
					yym692 := z.EncBinary()
					_ = yym692
					if false {
					} else if z.HasExtensions() && z.EncExt(yy691) {
					} else {
						z.EncFallback(yy691)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq683[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy693 := &x.ListMeta
					yym694 := z.EncBinary()
					_ = yym694
					if false {
					} else if z.HasExtensions() && z.EncExt(yy693) {
					} else {
						z.EncFallback(yy693)
					}
				}
			}
			if yyr683 || yy2arr683 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym696 := z.EncBinary()
					_ = yym696
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym697 := z.EncBinary()
					_ = yym697
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep683 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj707 int
	var yyb707 bool
	var yyhl707 bool = l >= 0
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv710 := &x.ListMeta
		yym711 := z.DecBinary()
		_ = yym711
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv710) {
		} else {
			z.DecFallback(yyv710, false)
		}
	}
	yyj707++
	if yyhl707 {
		yyb707 = yyj707 > l
	} else {
		yyb707 = r.CheckBreak()
	}
	if yyb707 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv712 := &x.Items
		yym713 := z.DecBinary()
		_ = yym713
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv712), d)
		}
	}
	for {
		yyj707++
		if yyhl707 {
			yyb707 = yyj707 > l
		} else {
			yyb707 = r.CheckBreak()
		}
		if yyb707 {
			break
		}
		z.DecStructFieldNotFound(yyj707-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 {
		yym714 := z.EncBinary()
		_ = yym714
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep715 := !z.EncBinary()
			yy2arr715 := z.EncBasicHandle().StructToArray
			var yyq715 [4]bool
			_, _, _ = yysep715, yyq715, yy2arr715
			const yyr715 bool = false
			yyq715[0] = x.Parallelism != nil
			yyq715[1] = x.Completions != nil
			yyq715[2] = x.Selector != nil
			if yyr715 || yy2arr715 {
				r.EncodeArrayStart(4)
			} else {
				var yynn715 int = 1
				for _, b := range yyq715 {
					if b {
						yynn715++
					}
				}
				r.EncodeMapStart(yynn715)
			}
			if yyr715 || yy2arr715 {
				if yyq715[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy717 := *x.Parallelism
						yym718 := z.EncBinary()
						_ = yym718
						if false {
						} else {
							r.EncodeInt(int64(yy717))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq715[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy719 := *x.Parallelism
						yym720 := z.EncBinary()
						_ = yym720
						if false {
						} else {
							r.EncodeInt(int64(yy719))
						}
					}
				}
			}
			if yyr715 || yy2arr715 {
				if yyq715[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy722 := *x.Completions
						yym723 := z.EncBinary()
						_ = yym723
						if false {
						} else {
							r.EncodeInt(int64(yy722))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq715[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy724 := *x.Completions
						yym725 := z.EncBinary()
						_ = yym725
						if false {
						} else {
							r.EncodeInt(int64(yy724))
						}
					}
				}
			}
			if yyr715 || yy2arr715 {
				if yyq715[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq715[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr715 || yy2arr715 {
				yy728 := &x.Template
				yy728.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy729 := &x.Template
				yy729.CodecEncodeSelf(e)
			}
			if yysep715 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj739 int
	var yyb739 bool
	var yyhl739 bool = l >= 0
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int)
		}
		yym741 := z.DecBinary()
		_ = yym741
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int)
		}
		yym743 := z.DecBinary()
		_ = yym743
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		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)
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv745 := &x.Template
		yyv745.CodecDecodeSelf(d)
	}
	for {
		yyj739++
		if yyhl739 {
			yyb739 = yyj739 > l
		} else {
			yyb739 = r.CheckBreak()
		}
		if yyb739 {
			break
		}
		z.DecStructFieldNotFound(yyj739-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 {
		yym746 := z.EncBinary()
		_ = yym746
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep747 := !z.EncBinary()
			yy2arr747 := z.EncBasicHandle().StructToArray
			var yyq747 [6]bool
			_, _, _ = yysep747, yyq747, yy2arr747
			const yyr747 bool = false
			yyq747[0] = len(x.Conditions) != 0
			yyq747[1] = x.StartTime != nil
			yyq747[2] = x.CompletionTime != nil
			yyq747[3] = x.Active != 0
			yyq747[4] = x.Succeeded != 0
			yyq747[5] = x.Failed != 0
			if yyr747 || yy2arr747 {
				r.EncodeArrayStart(6)
			} else {
				var yynn747 int = 0
				for _, b := range yyq747 {
					if b {
						yynn747++
					}
				}
				r.EncodeMapStart(yynn747)
			}
			if yyr747 || yy2arr747 {
				if yyq747[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym749 := z.EncBinary()
						_ = yym749
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq747[0] {
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym750 := z.EncBinary()
						_ = yym750
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr747 || yy2arr747 {
				if yyq747[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym752 := z.EncBinary()
						_ = yym752
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym752 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym752 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq747[1] {
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym753 := z.EncBinary()
						_ = yym753
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym753 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym753 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr747 || yy2arr747 {
				if yyq747[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym755 := z.EncBinary()
						_ = yym755
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym755 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym755 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq747[2] {
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym756 := z.EncBinary()
						_ = yym756
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym756 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym756 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr747 || yy2arr747 {
				if yyq747[3] {
					yym758 := z.EncBinary()
					_ = yym758
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq747[3] {
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					yym759 := z.EncBinary()
					_ = yym759
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr747 || yy2arr747 {
				if yyq747[4] {
					yym761 := z.EncBinary()
					_ = yym761
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq747[4] {
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					yym762 := z.EncBinary()
					_ = yym762
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr747 || yy2arr747 {
				if yyq747[5] {
					yym764 := z.EncBinary()
					_ = yym764
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq747[5] {
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					yym765 := z.EncBinary()
					_ = yym765
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yysep747 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym788 := z.EncBinary()
	_ = yym788
	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
	yym789 := z.DecBinary()
	_ = yym789
	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 {
		yym790 := z.EncBinary()
		_ = yym790
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep791 := !z.EncBinary()
			yy2arr791 := z.EncBasicHandle().StructToArray
			var yyq791 [6]bool
			_, _, _ = yysep791, yyq791, yy2arr791
			const yyr791 bool = false
			yyq791[2] = true
			yyq791[3] = true
			yyq791[4] = x.Reason != ""
			yyq791[5] = x.Message != ""
			if yyr791 || yy2arr791 {
				r.EncodeArrayStart(6)
			} else {
				var yynn791 int = 2
				for _, b := range yyq791 {
					if b {
						yynn791++
					}
				}
				r.EncodeMapStart(yynn791)
			}
			if yyr791 || yy2arr791 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr791 || yy2arr791 {
				yym794 := z.EncBinary()
				_ = yym794
				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"))
				yym795 := z.EncBinary()
				_ = yym795
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr791 || yy2arr791 {
				if yyq791[2] {
					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)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq791[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy799 := &x.LastProbeTime
					yym800 := z.EncBinary()
					_ = yym800
					if false {
					} else if z.HasExtensions() && z.EncExt(yy799) {
					} else if yym800 {
						z.EncBinaryMarshal(yy799)
					} else if !yym800 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy799)
					} else {
						z.EncFallback(yy799)
					}
				}
			}
			if yyr791 || yy2arr791 {
				if yyq791[3] {
					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)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq791[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy804 := &x.LastTransitionTime
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else if z.HasExtensions() && z.EncExt(yy804) {
					} else if yym805 {
						z.EncBinaryMarshal(yy804)
					} else if !yym805 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy804)
					} else {
						z.EncFallback(yy804)
					}
				}
			}
			if yyr791 || yy2arr791 {
				if yyq791[4] {
					yym807 := z.EncBinary()
					_ = yym807
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq791[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym808 := z.EncBinary()
					_ = yym808
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr791 || yy2arr791 {
				if yyq791[5] {
					yym810 := z.EncBinary()
					_ = yym810
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq791[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym811 := z.EncBinary()
					_ = yym811
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep791 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym812 := z.DecBinary()
	_ = yym812
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl813 := r.ReadMapStart()
			if yyl813 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl813, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl813 := r.ReadArrayStart()
			if yyl813 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl813, 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 yys814Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys814Slc
	var yyhl814 bool = l >= 0
	for yyj814 := 0; ; yyj814++ {
		if yyhl814 {
			if yyj814 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys814Slc = r.DecodeBytes(yys814Slc, true, true)
		yys814 := string(yys814Slc)
		switch yys814 {
		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 {
				yyv817 := &x.LastProbeTime
				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 "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv819 := &x.LastTransitionTime
				yym820 := z.DecBinary()
				_ = yym820
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv819) {
				} else if yym820 {
					z.DecBinaryUnmarshal(yyv819)
				} else if !yym820 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv819)
				} else {
					z.DecFallback(yyv819, 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, yys814)
		} // end switch yys814
	} // end for yyj814
	if !yyhl814 {
		r.ReadEnd()
	}
}

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj823 int
	var yyb823 bool
	var yyhl823 bool = l >= 0
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv826 := &x.LastProbeTime
		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)
		}
	}
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv828 := &x.LastTransitionTime
		yym829 := z.DecBinary()
		_ = yym829
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv828) {
		} else if yym829 {
			z.DecBinaryUnmarshal(yyv828)
		} else if !yym829 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv828)
		} else {
			z.DecFallback(yyv828, false)
		}
	}
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj823++
	if yyhl823 {
		yyb823 = yyj823 > l
	} else {
		yyb823 = r.CheckBreak()
	}
	if yyb823 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj823++
		if yyhl823 {
			yyb823 = yyj823 > l
		} else {
			yyb823 = r.CheckBreak()
		}
		if yyb823 {
			break
		}
		z.DecStructFieldNotFound(yyj823-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 {
		yym832 := z.EncBinary()
		_ = yym832
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep833 := !z.EncBinary()
			yy2arr833 := z.EncBasicHandle().StructToArray
			var yyq833 [5]bool
			_, _, _ = yysep833, yyq833, yy2arr833
			const yyr833 bool = false
			yyq833[0] = x.Kind != ""
			yyq833[1] = x.APIVersion != ""
			yyq833[2] = true
			yyq833[3] = true
			yyq833[4] = true
			if yyr833 || yy2arr833 {
				r.EncodeArrayStart(5)
			} else {
				var yynn833 int = 0
				for _, b := range yyq833 {
					if b {
						yynn833++
					}
				}
				r.EncodeMapStart(yynn833)
			}
			if yyr833 || yy2arr833 {
				if yyq833[0] {
					yym835 := z.EncBinary()
					_ = yym835
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq833[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym836 := z.EncBinary()
					_ = yym836
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr833 || yy2arr833 {
				if yyq833[1] {
					yym838 := z.EncBinary()
					_ = yym838
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq833[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym839 := z.EncBinary()
					_ = yym839
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr833 || yy2arr833 {
				if yyq833[2] {
					yy841 := &x.ObjectMeta
					yy841.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq833[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy842 := &x.ObjectMeta
					yy842.CodecEncodeSelf(e)
				}
			}
			if yyr833 || yy2arr833 {
				if yyq833[3] {
					yy844 := &x.Spec
					yy844.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq833[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy845 := &x.Spec
					yy845.CodecEncodeSelf(e)
				}
			}
			if yyr833 || yy2arr833 {
				if yyq833[4] {
					yy847 := &x.Status
					yy847.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq833[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy848 := &x.Status
					yy848.CodecEncodeSelf(e)
				}
			}
			if yysep833 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *Ingress) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym849 := z.DecBinary()
	_ = yym849
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl850 := r.ReadMapStart()
			if yyl850 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl850, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl850 := r.ReadArrayStart()
			if yyl850 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl850, 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 yys851Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys851Slc
	var yyhl851 bool = l >= 0
	for yyj851 := 0; ; yyj851++ {
		if yyhl851 {
			if yyj851 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys851Slc = r.DecodeBytes(yys851Slc, true, true)
		yys851 := string(yys851Slc)
		switch yys851 {
		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 {
				yyv854 := &x.ObjectMeta
				yyv854.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv855 := &x.Spec
				yyv855.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv856 := &x.Status
				yyv856.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys851)
		} // end switch yys851
	} // end for yyj851
	if !yyhl851 {
		r.ReadEnd()
	}
}

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj857 int
	var yyb857 bool
	var yyhl857 bool = l >= 0
	yyj857++
	if yyhl857 {
		yyb857 = yyj857 > l
	} else {
		yyb857 = r.CheckBreak()
	}
	if yyb857 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj857++
	if yyhl857 {
		yyb857 = yyj857 > l
	} else {
		yyb857 = r.CheckBreak()
	}
	if yyb857 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj857++
	if yyhl857 {
		yyb857 = yyj857 > l
	} else {
		yyb857 = r.CheckBreak()
	}
	if yyb857 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv860 := &x.ObjectMeta
		yyv860.CodecDecodeSelf(d)
	}
	yyj857++
	if yyhl857 {
		yyb857 = yyj857 > l
	} else {
		yyb857 = r.CheckBreak()
	}
	if yyb857 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv861 := &x.Spec
		yyv861.CodecDecodeSelf(d)
	}
	yyj857++
	if yyhl857 {
		yyb857 = yyj857 > l
	} else {
		yyb857 = r.CheckBreak()
	}
	if yyb857 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv862 := &x.Status
		yyv862.CodecDecodeSelf(d)
	}
	for {
		yyj857++
		if yyhl857 {
			yyb857 = yyj857 > l
		} else {
			yyb857 = r.CheckBreak()
		}
		if yyb857 {
			break
		}
		z.DecStructFieldNotFound(yyj857-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 {
		yym863 := z.EncBinary()
		_ = yym863
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep864 := !z.EncBinary()
			yy2arr864 := z.EncBasicHandle().StructToArray
			var yyq864 [4]bool
			_, _, _ = yysep864, yyq864, yy2arr864
			const yyr864 bool = false
			yyq864[0] = x.Kind != ""
			yyq864[1] = x.APIVersion != ""
			yyq864[2] = true
			if yyr864 || yy2arr864 {
				r.EncodeArrayStart(4)
			} else {
				var yynn864 int = 1
				for _, b := range yyq864 {
					if b {
						yynn864++
					}
				}
				r.EncodeMapStart(yynn864)
			}
			if yyr864 || yy2arr864 {
				if yyq864[0] {
					yym866 := z.EncBinary()
					_ = yym866
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq864[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym867 := z.EncBinary()
					_ = yym867
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr864 || yy2arr864 {
				if yyq864[1] {
					yym869 := z.EncBinary()
					_ = yym869
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq864[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym870 := z.EncBinary()
					_ = yym870
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr864 || yy2arr864 {
				if yyq864[2] {
					yy872 := &x.ListMeta
					yym873 := z.EncBinary()
					_ = yym873
					if false {
					} else if z.HasExtensions() && z.EncExt(yy872) {
					} else {
						z.EncFallback(yy872)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq864[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy874 := &x.ListMeta
					yym875 := z.EncBinary()
					_ = yym875
					if false {
					} else if z.HasExtensions() && z.EncExt(yy874) {
					} else {
						z.EncFallback(yy874)
					}
				}
			}
			if yyr864 || yy2arr864 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym877 := z.EncBinary()
					_ = yym877
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym878 := z.EncBinary()
					_ = yym878
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep864 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj888 int
	var yyb888 bool
	var yyhl888 bool = l >= 0
	yyj888++
	if yyhl888 {
		yyb888 = yyj888 > l
	} else {
		yyb888 = r.CheckBreak()
	}
	if yyb888 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj888++
	if yyhl888 {
		yyb888 = yyj888 > l
	} else {
		yyb888 = r.CheckBreak()
	}
	if yyb888 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj888++
	if yyhl888 {
		yyb888 = yyj888 > l
	} else {
		yyb888 = r.CheckBreak()
	}
	if yyb888 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv891 := &x.ListMeta
		yym892 := z.DecBinary()
		_ = yym892
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv891) {
		} else {
			z.DecFallback(yyv891, false)
		}
	}
	yyj888++
	if yyhl888 {
		yyb888 = yyj888 > l
	} else {
		yyb888 = r.CheckBreak()
	}
	if yyb888 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv893 := &x.Items
		yym894 := z.DecBinary()
		_ = yym894
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv893), d)
		}
	}
	for {
		yyj888++
		if yyhl888 {
			yyb888 = yyj888 > l
		} else {
			yyb888 = r.CheckBreak()
		}
		if yyb888 {
			break
		}
		z.DecStructFieldNotFound(yyj888-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 {
		yym895 := z.EncBinary()
		_ = yym895
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep896 := !z.EncBinary()
			yy2arr896 := z.EncBasicHandle().StructToArray
			var yyq896 [2]bool
			_, _, _ = yysep896, yyq896, yy2arr896
			const yyr896 bool = false
			yyq896[0] = x.Backend != nil
			yyq896[1] = len(x.Rules) != 0
			if yyr896 || yy2arr896 {
				r.EncodeArrayStart(2)
			} else {
				var yynn896 int = 0
				for _, b := range yyq896 {
					if b {
						yynn896++
					}
				}
				r.EncodeMapStart(yynn896)
			}
			if yyr896 || yy2arr896 {
				if yyq896[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq896[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr896 || yy2arr896 {
				if yyq896[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym899 := z.EncBinary()
						_ = yym899
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq896[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym900 := z.EncBinary()
						_ = yym900
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep896 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj907 int
	var yyb907 bool
	var yyhl907 bool = l >= 0
	yyj907++
	if yyhl907 {
		yyb907 = yyj907 > l
	} else {
		yyb907 = r.CheckBreak()
	}
	if yyb907 {
		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)
	}
	yyj907++
	if yyhl907 {
		yyb907 = yyj907 > l
	} else {
		yyb907 = r.CheckBreak()
	}
	if yyb907 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv909 := &x.Rules
		yym910 := z.DecBinary()
		_ = yym910
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv909), d)
		}
	}
	for {
		yyj907++
		if yyhl907 {
			yyb907 = yyj907 > l
		} else {
			yyb907 = r.CheckBreak()
		}
		if yyb907 {
			break
		}
		z.DecStructFieldNotFound(yyj907-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 {
		yym911 := z.EncBinary()
		_ = yym911
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep912 := !z.EncBinary()
			yy2arr912 := z.EncBasicHandle().StructToArray
			var yyq912 [1]bool
			_, _, _ = yysep912, yyq912, yy2arr912
			const yyr912 bool = false
			yyq912[0] = true
			if yyr912 || yy2arr912 {
				r.EncodeArrayStart(1)
			} else {
				var yynn912 int = 0
				for _, b := range yyq912 {
					if b {
						yynn912++
					}
				}
				r.EncodeMapStart(yynn912)
			}
			if yyr912 || yy2arr912 {
				if yyq912[0] {
					yy914 := &x.LoadBalancer
					yy914.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq912[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy915 := &x.LoadBalancer
					yy915.CodecEncodeSelf(e)
				}
			}
			if yysep912 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj920 int
	var yyb920 bool
	var yyhl920 bool = l >= 0
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv921 := &x.LoadBalancer
		yyv921.CodecDecodeSelf(d)
	}
	for {
		yyj920++
		if yyhl920 {
			yyb920 = yyj920 > l
		} else {
			yyb920 = r.CheckBreak()
		}
		if yyb920 {
			break
		}
		z.DecStructFieldNotFound(yyj920-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 {
		yym922 := z.EncBinary()
		_ = yym922
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep923 := !z.EncBinary()
			yy2arr923 := z.EncBasicHandle().StructToArray
			var yyq923 [2]bool
			_, _, _ = yysep923, yyq923, yy2arr923
			const yyr923 bool = false
			yyq923[0] = x.Host != ""
			yyq923[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr923 || yy2arr923 {
				r.EncodeArrayStart(2)
			} else {
				var yynn923 int = 0
				for _, b := range yyq923 {
					if b {
						yynn923++
					}
				}
				r.EncodeMapStart(yynn923)
			}
			if yyr923 || yy2arr923 {
				if yyq923[0] {
					yym925 := z.EncBinary()
					_ = yym925
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq923[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym926 := z.EncBinary()
					_ = yym926
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn927 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn927 = true
				goto LABEL927
			}
		LABEL927:
			if yyr923 || yy2arr923 {
				if yyn927 {
					r.EncodeNil()
				} else {
					if yyq923[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq923[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn927 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep923 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj943 int
	var yyb943 bool
	var yyhl943 bool = l >= 0
	yyj943++
	if yyhl943 {
		yyb943 = yyj943 > l
	} else {
		yyb943 = r.CheckBreak()
	}
	if yyb943 {
		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 {
		yyj943++
		if yyhl943 {
			yyb943 = yyj943 > l
		} else {
			yyb943 = r.CheckBreak()
		}
		if yyb943 {
			break
		}
		z.DecStructFieldNotFound(yyj943-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 {
		yym945 := z.EncBinary()
		_ = yym945
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep946 := !z.EncBinary()
			yy2arr946 := z.EncBasicHandle().StructToArray
			var yyq946 [1]bool
			_, _, _ = yysep946, yyq946, yy2arr946
			const yyr946 bool = false
			if yyr946 || yy2arr946 {
				r.EncodeArrayStart(1)
			} else {
				var yynn946 int = 1
				for _, b := range yyq946 {
					if b {
						yynn946++
					}
				}
				r.EncodeMapStart(yynn946)
			}
			if yyr946 || yy2arr946 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym948 := z.EncBinary()
					_ = yym948
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym949 := z.EncBinary()
					_ = yym949
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep946 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj955 int
	var yyb955 bool
	var yyhl955 bool = l >= 0
	yyj955++
	if yyhl955 {
		yyb955 = yyj955 > l
	} else {
		yyb955 = r.CheckBreak()
	}
	if yyb955 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv956 := &x.Paths
		yym957 := z.DecBinary()
		_ = yym957
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv956), d)
		}
	}
	for {
		yyj955++
		if yyhl955 {
			yyb955 = yyj955 > l
		} else {
			yyb955 = r.CheckBreak()
		}
		if yyb955 {
			break
		}
		z.DecStructFieldNotFound(yyj955-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 {
		yym958 := z.EncBinary()
		_ = yym958
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep959 := !z.EncBinary()
			yy2arr959 := z.EncBasicHandle().StructToArray
			var yyq959 [2]bool
			_, _, _ = yysep959, yyq959, yy2arr959
			const yyr959 bool = false
			yyq959[0] = x.Path != ""
			if yyr959 || yy2arr959 {
				r.EncodeArrayStart(2)
			} else {
				var yynn959 int = 1
				for _, b := range yyq959 {
					if b {
						yynn959++
					}
				}
				r.EncodeMapStart(yynn959)
			}
			if yyr959 || yy2arr959 {
				if yyq959[0] {
					yym961 := z.EncBinary()
					_ = yym961
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq959[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym962 := z.EncBinary()
					_ = yym962
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr959 || yy2arr959 {
				yy964 := &x.Backend
				yy964.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy965 := &x.Backend
				yy965.CodecEncodeSelf(e)
			}
			if yysep959 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj971 int
	var yyb971 bool
	var yyhl971 bool = l >= 0
	yyj971++
	if yyhl971 {
		yyb971 = yyj971 > l
	} else {
		yyb971 = r.CheckBreak()
	}
	if yyb971 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj971++
	if yyhl971 {
		yyb971 = yyj971 > l
	} else {
		yyb971 = r.CheckBreak()
	}
	if yyb971 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv973 := &x.Backend
		yyv973.CodecDecodeSelf(d)
	}
	for {
		yyj971++
		if yyhl971 {
			yyb971 = yyj971 > l
		} else {
			yyb971 = r.CheckBreak()
		}
		if yyb971 {
			break
		}
		z.DecStructFieldNotFound(yyj971-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 {
		yym974 := z.EncBinary()
		_ = yym974
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep975 := !z.EncBinary()
			yy2arr975 := z.EncBasicHandle().StructToArray
			var yyq975 [2]bool
			_, _, _ = yysep975, yyq975, yy2arr975
			const yyr975 bool = false
			if yyr975 || yy2arr975 {
				r.EncodeArrayStart(2)
			} else {
				var yynn975 int = 2
				for _, b := range yyq975 {
					if b {
						yynn975++
					}
				}
				r.EncodeMapStart(yynn975)
			}
			if yyr975 || yy2arr975 {
				yym977 := z.EncBinary()
				_ = yym977
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym978 := z.EncBinary()
				_ = yym978
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr975 || yy2arr975 {
				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)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy982 := &x.ServicePort
				yym983 := z.EncBinary()
				_ = yym983
				if false {
				} else if z.HasExtensions() && z.EncExt(yy982) {
				} else if !yym983 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy982)
				} else {
					z.EncFallback(yy982)
				}
			}
			if yysep975 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym994 := z.EncBinary()
	_ = yym994
	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
	yym995 := z.DecBinary()
	_ = yym995
	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 {
		yym996 := z.EncBinary()
		_ = yym996
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep997 := !z.EncBinary()
			yy2arr997 := z.EncBasicHandle().StructToArray
			var yyq997 [2]bool
			_, _, _ = yysep997, yyq997, yy2arr997
			const yyr997 bool = false
			if yyr997 || yy2arr997 {
				r.EncodeArrayStart(2)
			} else {
				var yynn997 int = 2
				for _, b := range yyq997 {
					if b {
						yynn997++
					}
				}
				r.EncodeMapStart(yynn997)
			}
			if yyr997 || yy2arr997 {
				x.Resource.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("resource"))
				x.Resource.CodecEncodeSelf(e)
			}
			if yyr997 || yy2arr997 {
				yym1000 := z.EncBinary()
				_ = yym1000
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				yym1001 := z.EncBinary()
				_ = yym1001
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yysep997 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *NodeUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1007 int
	var yyb1007 bool
	var yyhl1007 bool = l >= 0
	yyj1007++
	if yyhl1007 {
		yyb1007 = yyj1007 > l
	} else {
		yyb1007 = r.CheckBreak()
	}
	if yyb1007 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj1007++
	if yyhl1007 {
		yyb1007 = yyj1007 > l
	} else {
		yyb1007 = r.CheckBreak()
	}
	if yyb1007 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj1007++
		if yyhl1007 {
			yyb1007 = yyj1007 > l
		} else {
			yyb1007 = r.CheckBreak()
		}
		if yyb1007 {
			break
		}
		z.DecStructFieldNotFound(yyj1007-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 {
		yym1010 := z.EncBinary()
		_ = yym1010
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1011 := !z.EncBinary()
			yy2arr1011 := z.EncBasicHandle().StructToArray
			var yyq1011 [3]bool
			_, _, _ = yysep1011, yyq1011, yy2arr1011
			const yyr1011 bool = false
			if yyr1011 || yy2arr1011 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1011 int = 3
				for _, b := range yyq1011 {
					if b {
						yynn1011++
					}
				}
				r.EncodeMapStart(yynn1011)
			}
			if yyr1011 || yy2arr1011 {
				yym1013 := z.EncBinary()
				_ = yym1013
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				yym1014 := z.EncBinary()
				_ = yym1014
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1011 || yy2arr1011 {
				yym1016 := z.EncBinary()
				_ = yym1016
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				yym1017 := z.EncBinary()
				_ = yym1017
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1011 || yy2arr1011 {
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1019 := z.EncBinary()
					_ = yym1019
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1020 := z.EncBinary()
					_ = yym1020
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yysep1011 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1028 int
	var yyb1028 bool
	var yyhl1028 bool = l >= 0
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1031 := &x.TargetUtilization
		yym1032 := z.DecBinary()
		_ = yym1032
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1031), d)
		}
	}
	for {
		yyj1028++
		if yyhl1028 {
			yyb1028 = yyj1028 > l
		} else {
			yyb1028 = r.CheckBreak()
		}
		if yyb1028 {
			break
		}
		z.DecStructFieldNotFound(yyj1028-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 {
		yym1033 := z.EncBinary()
		_ = yym1033
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1034 := !z.EncBinary()
			yy2arr1034 := z.EncBasicHandle().StructToArray
			var yyq1034 [4]bool
			_, _, _ = yysep1034, yyq1034, yy2arr1034
			const yyr1034 bool = false
			yyq1034[0] = x.Kind != ""
			yyq1034[1] = x.APIVersion != ""
			yyq1034[2] = true
			yyq1034[3] = true
			if yyr1034 || yy2arr1034 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1034 int = 0
				for _, b := range yyq1034 {
					if b {
						yynn1034++
					}
				}
				r.EncodeMapStart(yynn1034)
			}
			if yyr1034 || yy2arr1034 {
				if yyq1034[0] {
					yym1036 := z.EncBinary()
					_ = yym1036
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1034[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1037 := z.EncBinary()
					_ = yym1037
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1034 || yy2arr1034 {
				if yyq1034[1] {
					yym1039 := z.EncBinary()
					_ = yym1039
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1034[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1040 := z.EncBinary()
					_ = yym1040
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1034 || yy2arr1034 {
				if yyq1034[2] {
					yy1042 := &x.ObjectMeta
					yy1042.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1034[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1043 := &x.ObjectMeta
					yy1043.CodecEncodeSelf(e)
				}
			}
			if yyr1034 || yy2arr1034 {
				if yyq1034[3] {
					yy1045 := &x.Spec
					yy1045.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1034[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1046 := &x.Spec
					yy1046.CodecEncodeSelf(e)
				}
			}
			if yysep1034 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *ClusterAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1047 := z.DecBinary()
	_ = yym1047
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl1048 := r.ReadMapStart()
			if yyl1048 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl1048, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl1048 := r.ReadArrayStart()
			if yyl1048 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl1048, 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 yys1049Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1049Slc
	var yyhl1049 bool = l >= 0
	for yyj1049 := 0; ; yyj1049++ {
		if yyhl1049 {
			if yyj1049 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys1049Slc = r.DecodeBytes(yys1049Slc, true, true)
		yys1049 := string(yys1049Slc)
		switch yys1049 {
		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 {
				yyv1052 := &x.ObjectMeta
				yyv1052.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ClusterAutoscalerSpec{}
			} else {
				yyv1053 := &x.Spec
				yyv1053.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1049)
		} // end switch yys1049
	} // end for yyj1049
	if !yyhl1049 {
		r.ReadEnd()
	}
}

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1054 int
	var yyb1054 bool
	var yyhl1054 bool = l >= 0
	yyj1054++
	if yyhl1054 {
		yyb1054 = yyj1054 > l
	} else {
		yyb1054 = r.CheckBreak()
	}
	if yyb1054 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1054++
	if yyhl1054 {
		yyb1054 = yyj1054 > l
	} else {
		yyb1054 = r.CheckBreak()
	}
	if yyb1054 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1054++
	if yyhl1054 {
		yyb1054 = yyj1054 > l
	} else {
		yyb1054 = r.CheckBreak()
	}
	if yyb1054 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1057 := &x.ObjectMeta
		yyv1057.CodecDecodeSelf(d)
	}
	yyj1054++
	if yyhl1054 {
		yyb1054 = yyj1054 > l
	} else {
		yyb1054 = r.CheckBreak()
	}
	if yyb1054 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1058 := &x.Spec
		yyv1058.CodecDecodeSelf(d)
	}
	for {
		yyj1054++
		if yyhl1054 {
			yyb1054 = yyj1054 > l
		} else {
			yyb1054 = r.CheckBreak()
		}
		if yyb1054 {
			break
		}
		z.DecStructFieldNotFound(yyj1054-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 {
		yym1059 := z.EncBinary()
		_ = yym1059
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1060 := !z.EncBinary()
			yy2arr1060 := z.EncBasicHandle().StructToArray
			var yyq1060 [4]bool
			_, _, _ = yysep1060, yyq1060, yy2arr1060
			const yyr1060 bool = false
			yyq1060[0] = x.Kind != ""
			yyq1060[1] = x.APIVersion != ""
			yyq1060[2] = true
			if yyr1060 || yy2arr1060 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1060 int = 1
				for _, b := range yyq1060 {
					if b {
						yynn1060++
					}
				}
				r.EncodeMapStart(yynn1060)
			}
			if yyr1060 || yy2arr1060 {
				if yyq1060[0] {
					yym1062 := z.EncBinary()
					_ = yym1062
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1060[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1063 := z.EncBinary()
					_ = yym1063
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1060 || yy2arr1060 {
				if yyq1060[1] {
					yym1065 := z.EncBinary()
					_ = yym1065
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1060[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1066 := z.EncBinary()
					_ = yym1066
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1060 || yy2arr1060 {
				if yyq1060[2] {
					yy1068 := &x.ListMeta
					yym1069 := z.EncBinary()
					_ = yym1069
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1068) {
					} else {
						z.EncFallback(yy1068)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1060[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1070 := &x.ListMeta
					yym1071 := z.EncBinary()
					_ = yym1071
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1070) {
					} else {
						z.EncFallback(yy1070)
					}
				}
			}
			if yyr1060 || yy2arr1060 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1073 := z.EncBinary()
					_ = yym1073
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1074 := z.EncBinary()
					_ = yym1074
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1060 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1084 int
	var yyb1084 bool
	var yyhl1084 bool = l >= 0
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1087 := &x.ListMeta
		yym1088 := z.DecBinary()
		_ = yym1088
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1087) {
		} else {
			z.DecFallback(yyv1087, false)
		}
	}
	yyj1084++
	if yyhl1084 {
		yyb1084 = yyj1084 > l
	} else {
		yyb1084 = r.CheckBreak()
	}
	if yyb1084 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1089 := &x.Items
		yym1090 := z.DecBinary()
		_ = yym1090
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1089), d)
		}
	}
	for {
		yyj1084++
		if yyhl1084 {
			yyb1084 = yyj1084 > l
		} else {
			yyb1084 = r.CheckBreak()
		}
		if yyb1084 {
			break
		}
		z.DecStructFieldNotFound(yyj1084-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 {
		yym1091 := z.EncBinary()
		_ = yym1091
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1092 := !z.EncBinary()
			yy2arr1092 := z.EncBasicHandle().StructToArray
			var yyq1092 [2]bool
			_, _, _ = yysep1092, yyq1092, yy2arr1092
			const yyr1092 bool = false
			yyq1092[0] = len(x.MatchLabels) != 0
			yyq1092[1] = len(x.MatchExpressions) != 0
			if yyr1092 || yy2arr1092 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1092 int = 0
				for _, b := range yyq1092 {
					if b {
						yynn1092++
					}
				}
				r.EncodeMapStart(yynn1092)
			}
			if yyr1092 || yy2arr1092 {
				if yyq1092[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1094 := z.EncBinary()
						_ = yym1094
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1092[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1095 := z.EncBinary()
						_ = yym1095
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1092 || yy2arr1092 {
				if yyq1092[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1097 := z.EncBinary()
						_ = yym1097
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1092[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1098 := z.EncBinary()
						_ = yym1098
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1092 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1106 int
	var yyb1106 bool
	var yyhl1106 bool = l >= 0
	yyj1106++
	if yyhl1106 {
		yyb1106 = yyj1106 > l
	} else {
		yyb1106 = r.CheckBreak()
	}
	if yyb1106 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1107 := &x.MatchLabels
		yym1108 := z.DecBinary()
		_ = yym1108
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1107, false, d)
		}
	}
	yyj1106++
	if yyhl1106 {
		yyb1106 = yyj1106 > l
	} else {
		yyb1106 = r.CheckBreak()
	}
	if yyb1106 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1109 := &x.MatchExpressions
		yym1110 := z.DecBinary()
		_ = yym1110
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1109), d)
		}
	}
	for {
		yyj1106++
		if yyhl1106 {
			yyb1106 = yyj1106 > l
		} else {
			yyb1106 = r.CheckBreak()
		}
		if yyb1106 {
			break
		}
		z.DecStructFieldNotFound(yyj1106-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 {
		yym1111 := z.EncBinary()
		_ = yym1111
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1112 := !z.EncBinary()
			yy2arr1112 := z.EncBasicHandle().StructToArray
			var yyq1112 [3]bool
			_, _, _ = yysep1112, yyq1112, yy2arr1112
			const yyr1112 bool = false
			yyq1112[2] = len(x.Values) != 0
			if yyr1112 || yy2arr1112 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1112 int = 2
				for _, b := range yyq1112 {
					if b {
						yynn1112++
					}
				}
				r.EncodeMapStart(yynn1112)
			}
			if yyr1112 || yy2arr1112 {
				yym1114 := z.EncBinary()
				_ = yym1114
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1115 := z.EncBinary()
				_ = yym1115
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1112 || yy2arr1112 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1112 || yy2arr1112 {
				if yyq1112[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1118 := z.EncBinary()
						_ = yym1118
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1112[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1119 := z.EncBinary()
						_ = yym1119
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1112 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

	yyv1136 := *v
	yyh1136, yyl1136 := z.DecSliceHelperStart()

	var yyrr1136, yyrl1136 int
	var yyc1136, yyrt1136 bool
	_, _, _ = yyc1136, yyrt1136, yyrl1136
	yyrr1136 = yyl1136

	if yyv1136 == nil {
		if yyrl1136, yyrt1136 = z.DecInferLen(yyl1136, z.DecBasicHandle().MaxInitLen, 336); yyrt1136 {
			yyrr1136 = yyrl1136
		}
		yyv1136 = make([]HorizontalPodAutoscaler, yyrl1136)
		yyc1136 = true
	}

	if yyl1136 == 0 {
		if len(yyv1136) != 0 {
			yyv1136 = yyv1136[:0]
			yyc1136 = true
		}
	} else if yyl1136 > 0 {

		if yyl1136 > cap(yyv1136) {
			yyrl1136, yyrt1136 = z.DecInferLen(yyl1136, z.DecBasicHandle().MaxInitLen, 336)
			yyv1136 = make([]HorizontalPodAutoscaler, yyrl1136)
			yyc1136 = true

			yyrr1136 = len(yyv1136)
		} else if yyl1136 != len(yyv1136) {
			yyv1136 = yyv1136[:yyl1136]
			yyc1136 = true
		}
		yyj1136 := 0
		for ; yyj1136 < yyrr1136; yyj1136++ {
			if r.TryDecodeAsNil() {
				yyv1136[yyj1136] = HorizontalPodAutoscaler{}
			} else {
				yyv1137 := &yyv1136[yyj1136]
				yyv1137.CodecDecodeSelf(d)
			}

		}
		if yyrt1136 {
			for ; yyj1136 < yyl1136; yyj1136++ {
				yyv1136 = append(yyv1136, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1136[yyj1136] = HorizontalPodAutoscaler{}
				} else {
					yyv1138 := &yyv1136[yyj1136]
					yyv1138.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1136 := 0; !r.CheckBreak(); yyj1136++ {
			if yyj1136 >= len(yyv1136) {
				yyv1136 = append(yyv1136, HorizontalPodAutoscaler{}) // var yyz1136 HorizontalPodAutoscaler
				yyc1136 = true
			}

			if yyj1136 < len(yyv1136) {
				if r.TryDecodeAsNil() {
					yyv1136[yyj1136] = HorizontalPodAutoscaler{}
				} else {
					yyv1139 := &yyv1136[yyj1136]
					yyv1139.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1136.End()
	}
	if yyc1136 {
		*v = yyv1136
	}

}

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

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

	yyv1142 := *v
	yyh1142, yyl1142 := z.DecSliceHelperStart()

	var yyrr1142, yyrl1142 int
	var yyc1142, yyrt1142 bool
	_, _, _ = yyc1142, yyrt1142, yyrl1142
	yyrr1142 = yyl1142

	if yyv1142 == nil {
		if yyrl1142, yyrt1142 = z.DecInferLen(yyl1142, z.DecBasicHandle().MaxInitLen, 32); yyrt1142 {
			yyrr1142 = yyrl1142
		}
		yyv1142 = make([]APIVersion, yyrl1142)
		yyc1142 = true
	}

	if yyl1142 == 0 {
		if len(yyv1142) != 0 {
			yyv1142 = yyv1142[:0]
			yyc1142 = true
		}
	} else if yyl1142 > 0 {

		if yyl1142 > cap(yyv1142) {
			yyrl1142, yyrt1142 = z.DecInferLen(yyl1142, z.DecBasicHandle().MaxInitLen, 32)
			yyv1142 = make([]APIVersion, yyrl1142)
			yyc1142 = true

			yyrr1142 = len(yyv1142)
		} else if yyl1142 != len(yyv1142) {
			yyv1142 = yyv1142[:yyl1142]
			yyc1142 = true
		}
		yyj1142 := 0
		for ; yyj1142 < yyrr1142; yyj1142++ {
			if r.TryDecodeAsNil() {
				yyv1142[yyj1142] = APIVersion{}
			} else {
				yyv1143 := &yyv1142[yyj1142]
				yyv1143.CodecDecodeSelf(d)
			}

		}
		if yyrt1142 {
			for ; yyj1142 < yyl1142; yyj1142++ {
				yyv1142 = append(yyv1142, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1142[yyj1142] = APIVersion{}
				} else {
					yyv1144 := &yyv1142[yyj1142]
					yyv1144.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1142 := 0; !r.CheckBreak(); yyj1142++ {
			if yyj1142 >= len(yyv1142) {
				yyv1142 = append(yyv1142, APIVersion{}) // var yyz1142 APIVersion
				yyc1142 = true
			}

			if yyj1142 < len(yyv1142) {
				if r.TryDecodeAsNil() {
					yyv1142[yyj1142] = APIVersion{}
				} else {
					yyv1145 := &yyv1142[yyj1142]
					yyv1145.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1142.End()
	}
	if yyc1142 {
		*v = yyv1142
	}

}

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

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

	yyv1148 := *v
	yyh1148, yyl1148 := z.DecSliceHelperStart()

	var yyrr1148, yyrl1148 int
	var yyc1148, yyrt1148 bool
	_, _, _ = yyc1148, yyrt1148, yyrl1148
	yyrr1148 = yyl1148

	if yyv1148 == nil {
		if yyrl1148, yyrt1148 = z.DecInferLen(yyl1148, z.DecBasicHandle().MaxInitLen, 232); yyrt1148 {
			yyrr1148 = yyrl1148
		}
		yyv1148 = make([]ThirdPartyResource, yyrl1148)
		yyc1148 = true
	}

	if yyl1148 == 0 {
		if len(yyv1148) != 0 {
			yyv1148 = yyv1148[:0]
			yyc1148 = true
		}
	} else if yyl1148 > 0 {

		if yyl1148 > cap(yyv1148) {
			yyrl1148, yyrt1148 = z.DecInferLen(yyl1148, z.DecBasicHandle().MaxInitLen, 232)
			yyv1148 = make([]ThirdPartyResource, yyrl1148)
			yyc1148 = true

			yyrr1148 = len(yyv1148)
		} else if yyl1148 != len(yyv1148) {
			yyv1148 = yyv1148[:yyl1148]
			yyc1148 = true
		}
		yyj1148 := 0
		for ; yyj1148 < yyrr1148; yyj1148++ {
			if r.TryDecodeAsNil() {
				yyv1148[yyj1148] = ThirdPartyResource{}
			} else {
				yyv1149 := &yyv1148[yyj1148]
				yyv1149.CodecDecodeSelf(d)
			}

		}
		if yyrt1148 {
			for ; yyj1148 < yyl1148; yyj1148++ {
				yyv1148 = append(yyv1148, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1148[yyj1148] = ThirdPartyResource{}
				} else {
					yyv1150 := &yyv1148[yyj1148]
					yyv1150.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1148 := 0; !r.CheckBreak(); yyj1148++ {
			if yyj1148 >= len(yyv1148) {
				yyv1148 = append(yyv1148, ThirdPartyResource{}) // var yyz1148 ThirdPartyResource
				yyc1148 = true
			}

			if yyj1148 < len(yyv1148) {
				if r.TryDecodeAsNil() {
					yyv1148[yyj1148] = ThirdPartyResource{}
				} else {
					yyv1151 := &yyv1148[yyj1148]
					yyv1151.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1148.End()
	}
	if yyc1148 {
		*v = yyv1148
	}

}

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

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

	yyv1154 := *v
	yyh1154, yyl1154 := z.DecSliceHelperStart()

	var yyrr1154, yyrl1154 int
	var yyc1154, yyrt1154 bool
	_, _, _ = yyc1154, yyrt1154, yyrl1154
	yyrr1154 = yyl1154

	if yyv1154 == nil {
		if yyrl1154, yyrt1154 = z.DecInferLen(yyl1154, z.DecBasicHandle().MaxInitLen, 608); yyrt1154 {
			yyrr1154 = yyrl1154
		}
		yyv1154 = make([]Deployment, yyrl1154)
		yyc1154 = true
	}

	if yyl1154 == 0 {
		if len(yyv1154) != 0 {
			yyv1154 = yyv1154[:0]
			yyc1154 = true
		}
	} else if yyl1154 > 0 {

		if yyl1154 > cap(yyv1154) {
			yyrl1154, yyrt1154 = z.DecInferLen(yyl1154, z.DecBasicHandle().MaxInitLen, 608)
			yyv1154 = make([]Deployment, yyrl1154)
			yyc1154 = true

			yyrr1154 = len(yyv1154)
		} else if yyl1154 != len(yyv1154) {
			yyv1154 = yyv1154[:yyl1154]
			yyc1154 = true
		}
		yyj1154 := 0
		for ; yyj1154 < yyrr1154; yyj1154++ {
			if r.TryDecodeAsNil() {
				yyv1154[yyj1154] = Deployment{}
			} else {
				yyv1155 := &yyv1154[yyj1154]
				yyv1155.CodecDecodeSelf(d)
			}

		}
		if yyrt1154 {
			for ; yyj1154 < yyl1154; yyj1154++ {
				yyv1154 = append(yyv1154, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1154[yyj1154] = Deployment{}
				} else {
					yyv1156 := &yyv1154[yyj1154]
					yyv1156.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1154 := 0; !r.CheckBreak(); yyj1154++ {
			if yyj1154 >= len(yyv1154) {
				yyv1154 = append(yyv1154, Deployment{}) // var yyz1154 Deployment
				yyc1154 = true
			}

			if yyj1154 < len(yyv1154) {
				if r.TryDecodeAsNil() {
					yyv1154[yyj1154] = Deployment{}
				} else {
					yyv1157 := &yyv1154[yyj1154]
					yyv1157.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1154.End()
	}
	if yyc1154 {
		*v = yyv1154
	}

}

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

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

	yyv1160 := *v
	yyh1160, yyl1160 := z.DecSliceHelperStart()

	var yyrr1160, yyrl1160 int
	var yyc1160, yyrt1160 bool
	_, _, _ = yyc1160, yyrt1160, yyrl1160
	yyrr1160 = yyl1160

	if yyv1160 == nil {
		if yyrl1160, yyrt1160 = z.DecInferLen(yyl1160, z.DecBasicHandle().MaxInitLen, 232); yyrt1160 {
			yyrr1160 = yyrl1160
		}
		yyv1160 = make([]DaemonSet, yyrl1160)
		yyc1160 = true
	}

	if yyl1160 == 0 {
		if len(yyv1160) != 0 {
			yyv1160 = yyv1160[:0]
			yyc1160 = true
		}
	} else if yyl1160 > 0 {

		if yyl1160 > cap(yyv1160) {
			yyrl1160, yyrt1160 = z.DecInferLen(yyl1160, z.DecBasicHandle().MaxInitLen, 232)
			yyv1160 = make([]DaemonSet, yyrl1160)
			yyc1160 = true

			yyrr1160 = len(yyv1160)
		} else if yyl1160 != len(yyv1160) {
			yyv1160 = yyv1160[:yyl1160]
			yyc1160 = true
		}
		yyj1160 := 0
		for ; yyj1160 < yyrr1160; yyj1160++ {
			if r.TryDecodeAsNil() {
				yyv1160[yyj1160] = DaemonSet{}
			} else {
				yyv1161 := &yyv1160[yyj1160]
				yyv1161.CodecDecodeSelf(d)
			}

		}
		if yyrt1160 {
			for ; yyj1160 < yyl1160; yyj1160++ {
				yyv1160 = append(yyv1160, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1160[yyj1160] = DaemonSet{}
				} else {
					yyv1162 := &yyv1160[yyj1160]
					yyv1162.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1160 := 0; !r.CheckBreak(); yyj1160++ {
			if yyj1160 >= len(yyv1160) {
				yyv1160 = append(yyv1160, DaemonSet{}) // var yyz1160 DaemonSet
				yyc1160 = true
			}

			if yyj1160 < len(yyv1160) {
				if r.TryDecodeAsNil() {
					yyv1160[yyj1160] = DaemonSet{}
				} else {
					yyv1163 := &yyv1160[yyj1160]
					yyv1163.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1160.End()
	}
	if yyc1160 {
		*v = yyv1160
	}

}

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

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

	yyv1166 := *v
	yyh1166, yyl1166 := z.DecSliceHelperStart()

	var yyrr1166, yyrl1166 int
	var yyc1166, yyrt1166 bool
	_, _, _ = yyc1166, yyrt1166, yyrl1166
	yyrr1166 = yyl1166

	if yyv1166 == nil {
		if yyrl1166, yyrt1166 = z.DecInferLen(yyl1166, z.DecBasicHandle().MaxInitLen, 216); yyrt1166 {
			yyrr1166 = yyrl1166
		}
		yyv1166 = make([]ThirdPartyResourceData, yyrl1166)
		yyc1166 = true
	}

	if yyl1166 == 0 {
		if len(yyv1166) != 0 {
			yyv1166 = yyv1166[:0]
			yyc1166 = true
		}
	} else if yyl1166 > 0 {

		if yyl1166 > cap(yyv1166) {
			yyrl1166, yyrt1166 = z.DecInferLen(yyl1166, z.DecBasicHandle().MaxInitLen, 216)
			yyv1166 = make([]ThirdPartyResourceData, yyrl1166)
			yyc1166 = true

			yyrr1166 = len(yyv1166)
		} else if yyl1166 != len(yyv1166) {
			yyv1166 = yyv1166[:yyl1166]
			yyc1166 = true
		}
		yyj1166 := 0
		for ; yyj1166 < yyrr1166; yyj1166++ {
			if r.TryDecodeAsNil() {
				yyv1166[yyj1166] = ThirdPartyResourceData{}
			} else {
				yyv1167 := &yyv1166[yyj1166]
				yyv1167.CodecDecodeSelf(d)
			}

		}
		if yyrt1166 {
			for ; yyj1166 < yyl1166; yyj1166++ {
				yyv1166 = append(yyv1166, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1166[yyj1166] = ThirdPartyResourceData{}
				} else {
					yyv1168 := &yyv1166[yyj1166]
					yyv1168.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1166 := 0; !r.CheckBreak(); yyj1166++ {
			if yyj1166 >= len(yyv1166) {
				yyv1166 = append(yyv1166, ThirdPartyResourceData{}) // var yyz1166 ThirdPartyResourceData
				yyc1166 = true
			}

			if yyj1166 < len(yyv1166) {
				if r.TryDecodeAsNil() {
					yyv1166[yyj1166] = ThirdPartyResourceData{}
				} else {
					yyv1169 := &yyv1166[yyj1166]
					yyv1169.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1166.End()
	}
	if yyc1166 {
		*v = yyv1166
	}

}

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

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

	yyv1172 := *v
	yyh1172, yyl1172 := z.DecSliceHelperStart()

	var yyrr1172, yyrl1172 int
	var yyc1172, yyrt1172 bool
	_, _, _ = yyc1172, yyrt1172, yyrl1172
	yyrr1172 = yyl1172

	if yyv1172 == nil {
		if yyrl1172, yyrt1172 = z.DecInferLen(yyl1172, z.DecBasicHandle().MaxInitLen, 632); yyrt1172 {
			yyrr1172 = yyrl1172
		}
		yyv1172 = make([]Job, yyrl1172)
		yyc1172 = true
	}

	if yyl1172 == 0 {
		if len(yyv1172) != 0 {
			yyv1172 = yyv1172[:0]
			yyc1172 = true
		}
	} else if yyl1172 > 0 {

		if yyl1172 > cap(yyv1172) {
			yyrl1172, yyrt1172 = z.DecInferLen(yyl1172, z.DecBasicHandle().MaxInitLen, 632)
			yyv1172 = make([]Job, yyrl1172)
			yyc1172 = true

			yyrr1172 = len(yyv1172)
		} else if yyl1172 != len(yyv1172) {
			yyv1172 = yyv1172[:yyl1172]
			yyc1172 = true
		}
		yyj1172 := 0
		for ; yyj1172 < yyrr1172; yyj1172++ {
			if r.TryDecodeAsNil() {
				yyv1172[yyj1172] = Job{}
			} else {
				yyv1173 := &yyv1172[yyj1172]
				yyv1173.CodecDecodeSelf(d)
			}

		}
		if yyrt1172 {
			for ; yyj1172 < yyl1172; yyj1172++ {
				yyv1172 = append(yyv1172, Job{})
				if r.TryDecodeAsNil() {
					yyv1172[yyj1172] = Job{}
				} else {
					yyv1174 := &yyv1172[yyj1172]
					yyv1174.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1172 := 0; !r.CheckBreak(); yyj1172++ {
			if yyj1172 >= len(yyv1172) {
				yyv1172 = append(yyv1172, Job{}) // var yyz1172 Job
				yyc1172 = true
			}

			if yyj1172 < len(yyv1172) {
				if r.TryDecodeAsNil() {
					yyv1172[yyj1172] = Job{}
				} else {
					yyv1175 := &yyv1172[yyj1172]
					yyv1175.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1172.End()
	}
	if yyc1172 {
		*v = yyv1172
	}

}

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

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

	yyv1178 := *v
	yyh1178, yyl1178 := z.DecSliceHelperStart()

	var yyrr1178, yyrl1178 int
	var yyc1178, yyrt1178 bool
	_, _, _ = yyc1178, yyrt1178, yyrl1178
	yyrr1178 = yyl1178

	if yyv1178 == nil {
		if yyrl1178, yyrt1178 = z.DecInferLen(yyl1178, z.DecBasicHandle().MaxInitLen, 112); yyrt1178 {
			yyrr1178 = yyrl1178
		}
		yyv1178 = make([]JobCondition, yyrl1178)
		yyc1178 = true
	}

	if yyl1178 == 0 {
		if len(yyv1178) != 0 {
			yyv1178 = yyv1178[:0]
			yyc1178 = true
		}
	} else if yyl1178 > 0 {

		if yyl1178 > cap(yyv1178) {
			yyrl1178, yyrt1178 = z.DecInferLen(yyl1178, z.DecBasicHandle().MaxInitLen, 112)
			yyv1178 = make([]JobCondition, yyrl1178)
			yyc1178 = true

			yyrr1178 = len(yyv1178)
		} else if yyl1178 != len(yyv1178) {
			yyv1178 = yyv1178[:yyl1178]
			yyc1178 = true
		}
		yyj1178 := 0
		for ; yyj1178 < yyrr1178; yyj1178++ {
			if r.TryDecodeAsNil() {
				yyv1178[yyj1178] = JobCondition{}
			} else {
				yyv1179 := &yyv1178[yyj1178]
				yyv1179.CodecDecodeSelf(d)
			}

		}
		if yyrt1178 {
			for ; yyj1178 < yyl1178; yyj1178++ {
				yyv1178 = append(yyv1178, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1178[yyj1178] = JobCondition{}
				} else {
					yyv1180 := &yyv1178[yyj1178]
					yyv1180.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1178 := 0; !r.CheckBreak(); yyj1178++ {
			if yyj1178 >= len(yyv1178) {
				yyv1178 = append(yyv1178, JobCondition{}) // var yyz1178 JobCondition
				yyc1178 = true
			}

			if yyj1178 < len(yyv1178) {
				if r.TryDecodeAsNil() {
					yyv1178[yyj1178] = JobCondition{}
				} else {
					yyv1181 := &yyv1178[yyj1178]
					yyv1181.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1178.End()
	}
	if yyc1178 {
		*v = yyv1178
	}

}

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

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

	yyv1184 := *v
	yyh1184, yyl1184 := z.DecSliceHelperStart()

	var yyrr1184, yyrl1184 int
	var yyc1184, yyrt1184 bool
	_, _, _ = yyc1184, yyrt1184, yyrl1184
	yyrr1184 = yyl1184

	if yyv1184 == nil {
		if yyrl1184, yyrt1184 = z.DecInferLen(yyl1184, z.DecBasicHandle().MaxInitLen, 248); yyrt1184 {
			yyrr1184 = yyrl1184
		}
		yyv1184 = make([]Ingress, yyrl1184)
		yyc1184 = true
	}

	if yyl1184 == 0 {
		if len(yyv1184) != 0 {
			yyv1184 = yyv1184[:0]
			yyc1184 = true
		}
	} else if yyl1184 > 0 {

		if yyl1184 > cap(yyv1184) {
			yyrl1184, yyrt1184 = z.DecInferLen(yyl1184, z.DecBasicHandle().MaxInitLen, 248)
			yyv1184 = make([]Ingress, yyrl1184)
			yyc1184 = true

			yyrr1184 = len(yyv1184)
		} else if yyl1184 != len(yyv1184) {
			yyv1184 = yyv1184[:yyl1184]
			yyc1184 = true
		}
		yyj1184 := 0
		for ; yyj1184 < yyrr1184; yyj1184++ {
			if r.TryDecodeAsNil() {
				yyv1184[yyj1184] = Ingress{}
			} else {
				yyv1185 := &yyv1184[yyj1184]
				yyv1185.CodecDecodeSelf(d)
			}

		}
		if yyrt1184 {
			for ; yyj1184 < yyl1184; yyj1184++ {
				yyv1184 = append(yyv1184, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1184[yyj1184] = Ingress{}
				} else {
					yyv1186 := &yyv1184[yyj1184]
					yyv1186.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1184 := 0; !r.CheckBreak(); yyj1184++ {
			if yyj1184 >= len(yyv1184) {
				yyv1184 = append(yyv1184, Ingress{}) // var yyz1184 Ingress
				yyc1184 = true
			}

			if yyj1184 < len(yyv1184) {
				if r.TryDecodeAsNil() {
					yyv1184[yyj1184] = Ingress{}
				} else {
					yyv1187 := &yyv1184[yyj1184]
					yyv1187.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1184.End()
	}
	if yyc1184 {
		*v = yyv1184
	}

}

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

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

	yyv1190 := *v
	yyh1190, yyl1190 := z.DecSliceHelperStart()

	var yyrr1190, yyrl1190 int
	var yyc1190, yyrt1190 bool
	_, _, _ = yyc1190, yyrt1190, yyrl1190
	yyrr1190 = yyl1190

	if yyv1190 == nil {
		if yyrl1190, yyrt1190 = z.DecInferLen(yyl1190, z.DecBasicHandle().MaxInitLen, 24); yyrt1190 {
			yyrr1190 = yyrl1190
		}
		yyv1190 = make([]IngressRule, yyrl1190)
		yyc1190 = true
	}

	if yyl1190 == 0 {
		if len(yyv1190) != 0 {
			yyv1190 = yyv1190[:0]
			yyc1190 = true
		}
	} else if yyl1190 > 0 {

		if yyl1190 > cap(yyv1190) {
			yyrl1190, yyrt1190 = z.DecInferLen(yyl1190, z.DecBasicHandle().MaxInitLen, 24)
			yyv1190 = make([]IngressRule, yyrl1190)
			yyc1190 = true

			yyrr1190 = len(yyv1190)
		} else if yyl1190 != len(yyv1190) {
			yyv1190 = yyv1190[:yyl1190]
			yyc1190 = true
		}
		yyj1190 := 0
		for ; yyj1190 < yyrr1190; yyj1190++ {
			if r.TryDecodeAsNil() {
				yyv1190[yyj1190] = IngressRule{}
			} else {
				yyv1191 := &yyv1190[yyj1190]
				yyv1191.CodecDecodeSelf(d)
			}

		}
		if yyrt1190 {
			for ; yyj1190 < yyl1190; yyj1190++ {
				yyv1190 = append(yyv1190, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1190[yyj1190] = IngressRule{}
				} else {
					yyv1192 := &yyv1190[yyj1190]
					yyv1192.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1190 := 0; !r.CheckBreak(); yyj1190++ {
			if yyj1190 >= len(yyv1190) {
				yyv1190 = append(yyv1190, IngressRule{}) // var yyz1190 IngressRule
				yyc1190 = true
			}

			if yyj1190 < len(yyv1190) {
				if r.TryDecodeAsNil() {
					yyv1190[yyj1190] = IngressRule{}
				} else {
					yyv1193 := &yyv1190[yyj1190]
					yyv1193.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1190.End()
	}
	if yyc1190 {
		*v = yyv1190
	}

}

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

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

	yyv1196 := *v
	yyh1196, yyl1196 := z.DecSliceHelperStart()

	var yyrr1196, yyrl1196 int
	var yyc1196, yyrt1196 bool
	_, _, _ = yyc1196, yyrt1196, yyrl1196
	yyrr1196 = yyl1196

	if yyv1196 == nil {
		if yyrl1196, yyrt1196 = z.DecInferLen(yyl1196, z.DecBasicHandle().MaxInitLen, 64); yyrt1196 {
			yyrr1196 = yyrl1196
		}
		yyv1196 = make([]HTTPIngressPath, yyrl1196)
		yyc1196 = true
	}

	if yyl1196 == 0 {
		if len(yyv1196) != 0 {
			yyv1196 = yyv1196[:0]
			yyc1196 = true
		}
	} else if yyl1196 > 0 {

		if yyl1196 > cap(yyv1196) {
			yyrl1196, yyrt1196 = z.DecInferLen(yyl1196, z.DecBasicHandle().MaxInitLen, 64)
			yyv1196 = make([]HTTPIngressPath, yyrl1196)
			yyc1196 = true

			yyrr1196 = len(yyv1196)
		} else if yyl1196 != len(yyv1196) {
			yyv1196 = yyv1196[:yyl1196]
			yyc1196 = true
		}
		yyj1196 := 0
		for ; yyj1196 < yyrr1196; yyj1196++ {
			if r.TryDecodeAsNil() {
				yyv1196[yyj1196] = HTTPIngressPath{}
			} else {
				yyv1197 := &yyv1196[yyj1196]
				yyv1197.CodecDecodeSelf(d)
			}

		}
		if yyrt1196 {
			for ; yyj1196 < yyl1196; yyj1196++ {
				yyv1196 = append(yyv1196, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1196[yyj1196] = HTTPIngressPath{}
				} else {
					yyv1198 := &yyv1196[yyj1196]
					yyv1198.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1196 := 0; !r.CheckBreak(); yyj1196++ {
			if yyj1196 >= len(yyv1196) {
				yyv1196 = append(yyv1196, HTTPIngressPath{}) // var yyz1196 HTTPIngressPath
				yyc1196 = true
			}

			if yyj1196 < len(yyv1196) {
				if r.TryDecodeAsNil() {
					yyv1196[yyj1196] = HTTPIngressPath{}
				} else {
					yyv1199 := &yyv1196[yyj1196]
					yyv1199.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1196.End()
	}
	if yyc1196 {
		*v = yyv1196
	}

}

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

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

	yyv1202 := *v
	yyh1202, yyl1202 := z.DecSliceHelperStart()

	var yyrr1202, yyrl1202 int
	var yyc1202, yyrt1202 bool
	_, _, _ = yyc1202, yyrt1202, yyrl1202
	yyrr1202 = yyl1202

	if yyv1202 == nil {
		if yyrl1202, yyrt1202 = z.DecInferLen(yyl1202, z.DecBasicHandle().MaxInitLen, 24); yyrt1202 {
			yyrr1202 = yyrl1202
		}
		yyv1202 = make([]NodeUtilization, yyrl1202)
		yyc1202 = true
	}

	if yyl1202 == 0 {
		if len(yyv1202) != 0 {
			yyv1202 = yyv1202[:0]
			yyc1202 = true
		}
	} else if yyl1202 > 0 {

		if yyl1202 > cap(yyv1202) {
			yyrl1202, yyrt1202 = z.DecInferLen(yyl1202, z.DecBasicHandle().MaxInitLen, 24)
			yyv1202 = make([]NodeUtilization, yyrl1202)
			yyc1202 = true

			yyrr1202 = len(yyv1202)
		} else if yyl1202 != len(yyv1202) {
			yyv1202 = yyv1202[:yyl1202]
			yyc1202 = true
		}
		yyj1202 := 0
		for ; yyj1202 < yyrr1202; yyj1202++ {
			if r.TryDecodeAsNil() {
				yyv1202[yyj1202] = NodeUtilization{}
			} else {
				yyv1203 := &yyv1202[yyj1202]
				yyv1203.CodecDecodeSelf(d)
			}

		}
		if yyrt1202 {
			for ; yyj1202 < yyl1202; yyj1202++ {
				yyv1202 = append(yyv1202, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1202[yyj1202] = NodeUtilization{}
				} else {
					yyv1204 := &yyv1202[yyj1202]
					yyv1204.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1202 := 0; !r.CheckBreak(); yyj1202++ {
			if yyj1202 >= len(yyv1202) {
				yyv1202 = append(yyv1202, NodeUtilization{}) // var yyz1202 NodeUtilization
				yyc1202 = true
			}

			if yyj1202 < len(yyv1202) {
				if r.TryDecodeAsNil() {
					yyv1202[yyj1202] = NodeUtilization{}
				} else {
					yyv1205 := &yyv1202[yyj1202]
					yyv1205.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1202.End()
	}
	if yyc1202 {
		*v = yyv1202
	}

}

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

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

	yyv1208 := *v
	yyh1208, yyl1208 := z.DecSliceHelperStart()

	var yyrr1208, yyrl1208 int
	var yyc1208, yyrt1208 bool
	_, _, _ = yyc1208, yyrt1208, yyrl1208
	yyrr1208 = yyl1208

	if yyv1208 == nil {
		if yyrl1208, yyrt1208 = z.DecInferLen(yyl1208, z.DecBasicHandle().MaxInitLen, 232); yyrt1208 {
			yyrr1208 = yyrl1208
		}
		yyv1208 = make([]ClusterAutoscaler, yyrl1208)
		yyc1208 = true
	}

	if yyl1208 == 0 {
		if len(yyv1208) != 0 {
			yyv1208 = yyv1208[:0]
			yyc1208 = true
		}
	} else if yyl1208 > 0 {

		if yyl1208 > cap(yyv1208) {
			yyrl1208, yyrt1208 = z.DecInferLen(yyl1208, z.DecBasicHandle().MaxInitLen, 232)
			yyv1208 = make([]ClusterAutoscaler, yyrl1208)
			yyc1208 = true

			yyrr1208 = len(yyv1208)
		} else if yyl1208 != len(yyv1208) {
			yyv1208 = yyv1208[:yyl1208]
			yyc1208 = true
		}
		yyj1208 := 0
		for ; yyj1208 < yyrr1208; yyj1208++ {
			if r.TryDecodeAsNil() {
				yyv1208[yyj1208] = ClusterAutoscaler{}
			} else {
				yyv1209 := &yyv1208[yyj1208]
				yyv1209.CodecDecodeSelf(d)
			}

		}
		if yyrt1208 {
			for ; yyj1208 < yyl1208; yyj1208++ {
				yyv1208 = append(yyv1208, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1208[yyj1208] = ClusterAutoscaler{}
				} else {
					yyv1210 := &yyv1208[yyj1208]
					yyv1210.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1208 := 0; !r.CheckBreak(); yyj1208++ {
			if yyj1208 >= len(yyv1208) {
				yyv1208 = append(yyv1208, ClusterAutoscaler{}) // var yyz1208 ClusterAutoscaler
				yyc1208 = true
			}

			if yyj1208 < len(yyv1208) {
				if r.TryDecodeAsNil() {
					yyv1208[yyj1208] = ClusterAutoscaler{}
				} else {
					yyv1211 := &yyv1208[yyj1208]
					yyv1211.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1208.End()
	}
	if yyc1208 {
		*v = yyv1208
	}

}

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

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

	yyv1214 := *v
	yyh1214, yyl1214 := z.DecSliceHelperStart()

	var yyrr1214, yyrl1214 int
	var yyc1214, yyrt1214 bool
	_, _, _ = yyc1214, yyrt1214, yyrl1214
	yyrr1214 = yyl1214

	if yyv1214 == nil {
		if yyrl1214, yyrt1214 = z.DecInferLen(yyl1214, z.DecBasicHandle().MaxInitLen, 56); yyrt1214 {
			yyrr1214 = yyrl1214
		}
		yyv1214 = make([]PodSelectorRequirement, yyrl1214)
		yyc1214 = true
	}

	if yyl1214 == 0 {
		if len(yyv1214) != 0 {
			yyv1214 = yyv1214[:0]
			yyc1214 = true
		}
	} else if yyl1214 > 0 {

		if yyl1214 > cap(yyv1214) {
			yyrl1214, yyrt1214 = z.DecInferLen(yyl1214, z.DecBasicHandle().MaxInitLen, 56)
			yyv1214 = make([]PodSelectorRequirement, yyrl1214)
			yyc1214 = true

			yyrr1214 = len(yyv1214)
		} else if yyl1214 != len(yyv1214) {
			yyv1214 = yyv1214[:yyl1214]
			yyc1214 = true
		}
		yyj1214 := 0
		for ; yyj1214 < yyrr1214; yyj1214++ {
			if r.TryDecodeAsNil() {
				yyv1214[yyj1214] = PodSelectorRequirement{}
			} else {
				yyv1215 := &yyv1214[yyj1214]
				yyv1215.CodecDecodeSelf(d)
			}

		}
		if yyrt1214 {
			for ; yyj1214 < yyl1214; yyj1214++ {
				yyv1214 = append(yyv1214, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1214[yyj1214] = PodSelectorRequirement{}
				} else {
					yyv1216 := &yyv1214[yyj1214]
					yyv1216.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1214 := 0; !r.CheckBreak(); yyj1214++ {
			if yyj1214 >= len(yyv1214) {
				yyv1214 = append(yyv1214, PodSelectorRequirement{}) // var yyz1214 PodSelectorRequirement
				yyc1214 = true
			}

			if yyj1214 < len(yyv1214) {
				if r.TryDecodeAsNil() {
					yyv1214[yyj1214] = PodSelectorRequirement{}
				} else {
					yyv1217 := &yyv1214[yyj1214]
					yyv1217.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1214.End()
	}
	if yyc1214 {
		*v = yyv1214
	}

}