/*
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 [4]bool
			_, _, _ = yysep78, yyq78, yy2arr78
			const yyr78 bool = false
			yyq78[0] = x.Kind != ""
			yyq78[1] = x.Name != ""
			yyq78[2] = x.APIVersion != ""
			yyq78[3] = x.Subresource != ""
			if yyr78 || yy2arr78 {
				r.EncodeArrayStart(4)
			} 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.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[1] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					yym84 := z.EncBinary()
					_ = yym84
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[2] {
					yym86 := z.EncBinary()
					_ = yym86
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[2] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym87 := z.EncBinary()
					_ = yym87
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr78 || yy2arr78 {
				if yyq78[3] {
					yym89 := z.EncBinary()
					_ = yym89
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq78[3] {
					r.EncodeString(codecSelferC_UTF81234, string("subresource"))
					yym90 := z.EncBinary()
					_ = yym90
					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
	yym91 := z.DecBinary()
	_ = yym91
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl92 := r.ReadMapStart()
			if yyl92 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl92, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl92 := r.ReadArrayStart()
			if yyl92 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl92, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

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

func (x *SubresourceReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj98 int
	var yyb98 bool
	var yyhl98 bool = l >= 0
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj98++
	if yyhl98 {
		yyb98 = yyj98 > l
	} else {
		yyb98 = r.CheckBreak()
	}
	if yyb98 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Subresource = ""
	} else {
		x.Subresource = string(r.DecodeString())
	}
	for {
		yyj98++
		if yyhl98 {
			yyb98 = yyj98 > l
		} else {
			yyb98 = r.CheckBreak()
		}
		if yyb98 {
			break
		}
		z.DecStructFieldNotFound(yyj98-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 {
		yym103 := z.EncBinary()
		_ = yym103
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep104 := !z.EncBinary()
			yy2arr104 := z.EncBasicHandle().StructToArray
			var yyq104 [1]bool
			_, _, _ = yysep104, yyq104, yy2arr104
			const yyr104 bool = false
			if yyr104 || yy2arr104 {
				r.EncodeArrayStart(1)
			} else {
				var yynn104 int = 1
				for _, b := range yyq104 {
					if b {
						yynn104++
					}
				}
				r.EncodeMapStart(yynn104)
			}
			if yyr104 || yy2arr104 {
				yym106 := z.EncBinary()
				_ = yym106
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("targetPercentage"))
				yym107 := z.EncBinary()
				_ = yym107
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			}
			if yysep104 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x *CPUTargetUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj112 int
	var yyb112 bool
	var yyhl112 bool = l >= 0
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetPercentage = 0
	} else {
		x.TargetPercentage = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj112++
		if yyhl112 {
			yyb112 = yyj112 > l
		} else {
			yyb112 = r.CheckBreak()
		}
		if yyb112 {
			break
		}
		z.DecStructFieldNotFound(yyj112-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 {
		yym114 := z.EncBinary()
		_ = yym114
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep115 := !z.EncBinary()
			yy2arr115 := z.EncBasicHandle().StructToArray
			var yyq115 [4]bool
			_, _, _ = yysep115, yyq115, yy2arr115
			const yyr115 bool = false
			yyq115[1] = x.MinReplicas != nil
			yyq115[3] = x.CPUUtilization != nil
			if yyr115 || yy2arr115 {
				r.EncodeArrayStart(4)
			} else {
				var yynn115 int = 2
				for _, b := range yyq115 {
					if b {
						yynn115++
					}
				}
				r.EncodeMapStart(yynn115)
			}
			if yyr115 || yy2arr115 {
				yy117 := &x.ScaleRef
				yy117.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
				yy118 := &x.ScaleRef
				yy118.CodecEncodeSelf(e)
			}
			if yyr115 || yy2arr115 {
				if yyq115[1] {
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy120 := *x.MinReplicas
						yym121 := z.EncBinary()
						_ = yym121
						if false {
						} else {
							r.EncodeInt(int64(yy120))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq115[1] {
					r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy122 := *x.MinReplicas
						yym123 := z.EncBinary()
						_ = yym123
						if false {
						} else {
							r.EncodeInt(int64(yy122))
						}
					}
				}
			}
			if yyr115 || yy2arr115 {
				yym125 := z.EncBinary()
				_ = yym125
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
				yym126 := z.EncBinary()
				_ = yym126
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			}
			if yyr115 || yy2arr115 {
				if yyq115[3] {
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq115[3] {
					r.EncodeString(codecSelferC_UTF81234, string("cpuUtilization"))
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				}
			}
			if yysep115 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys130Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys130Slc
	var yyhl130 bool = l >= 0
	for yyj130 := 0; ; yyj130++ {
		if yyhl130 {
			if yyj130 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys130Slc = r.DecodeBytes(yys130Slc, true, true)
		yys130 := string(yys130Slc)
		switch yys130 {
		case "scaleRef":
			if r.TryDecodeAsNil() {
				x.ScaleRef = SubresourceReference{}
			} else {
				yyv131 := &x.ScaleRef
				yyv131.CodecDecodeSelf(d)
			}
		case "minReplicas":
			if r.TryDecodeAsNil() {
				if x.MinReplicas != nil {
					x.MinReplicas = nil
				}
			} else {
				if x.MinReplicas == nil {
					x.MinReplicas = new(int)
				}
				yym133 := z.DecBinary()
				_ = yym133
				if false {
				} else {
					*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "cpuUtilization":
			if r.TryDecodeAsNil() {
				if x.CPUUtilization != nil {
					x.CPUUtilization = nil
				}
			} else {
				if x.CPUUtilization == nil {
					x.CPUUtilization = new(CPUTargetUtilization)
				}
				x.CPUUtilization.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys130)
		} // end switch yys130
	} // end for yyj130
	if !yyhl130 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj136 int
	var yyb136 bool
	var yyhl136 bool = l >= 0
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ScaleRef = SubresourceReference{}
	} else {
		yyv137 := &x.ScaleRef
		yyv137.CodecDecodeSelf(d)
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MinReplicas != nil {
			x.MinReplicas = nil
		}
	} else {
		if x.MinReplicas == nil {
			x.MinReplicas = new(int)
		}
		yym139 := z.DecBinary()
		_ = yym139
		if false {
		} else {
			*((*int)(x.MinReplicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxReplicas = 0
	} else {
		x.MaxReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj136++
	if yyhl136 {
		yyb136 = yyj136 > l
	} else {
		yyb136 = r.CheckBreak()
	}
	if yyb136 {
		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 {
		yyj136++
		if yyhl136 {
			yyb136 = yyj136 > l
		} else {
			yyb136 = r.CheckBreak()
		}
		if yyb136 {
			break
		}
		z.DecStructFieldNotFound(yyj136-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 {
		yym142 := z.EncBinary()
		_ = yym142
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep143 := !z.EncBinary()
			yy2arr143 := z.EncBasicHandle().StructToArray
			var yyq143 [5]bool
			_, _, _ = yysep143, yyq143, yy2arr143
			const yyr143 bool = false
			yyq143[0] = x.ObservedGeneration != nil
			yyq143[1] = x.LastScaleTime != nil
			yyq143[4] = x.CurrentCPUUtilizationPercentage != nil
			if yyr143 || yy2arr143 {
				r.EncodeArrayStart(5)
			} else {
				var yynn143 int = 2
				for _, b := range yyq143 {
					if b {
						yynn143++
					}
				}
				r.EncodeMapStart(yynn143)
			}
			if yyr143 || yy2arr143 {
				if yyq143[0] {
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy145 := *x.ObservedGeneration
						yym146 := z.EncBinary()
						_ = yym146
						if false {
						} else {
							r.EncodeInt(int64(yy145))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[0] {
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy147 := *x.ObservedGeneration
						yym148 := z.EncBinary()
						_ = yym148
						if false {
						} else {
							r.EncodeInt(int64(yy147))
						}
					}
				}
			}
			if yyr143 || yy2arr143 {
				if yyq143[1] {
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym150 := z.EncBinary()
						_ = yym150
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym150 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym150 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[1] {
					r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym151 := z.EncBinary()
						_ = yym151
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym151 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym151 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				}
			}
			if yyr143 || yy2arr143 {
				yym153 := z.EncBinary()
				_ = yym153
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
				yym154 := z.EncBinary()
				_ = yym154
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			}
			if yyr143 || yy2arr143 {
				yym156 := z.EncBinary()
				_ = yym156
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
				yym157 := z.EncBinary()
				_ = yym157
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			}
			if yyr143 || yy2arr143 {
				if yyq143[4] {
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy159 := *x.CurrentCPUUtilizationPercentage
						yym160 := z.EncBinary()
						_ = yym160
						if false {
						} else {
							r.EncodeInt(int64(yy159))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq143[4] {
					r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy161 := *x.CurrentCPUUtilizationPercentage
						yym162 := z.EncBinary()
						_ = yym162
						if false {
						} else {
							r.EncodeInt(int64(yy161))
						}
					}
				}
			}
			if yysep143 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys165Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys165Slc
	var yyhl165 bool = l >= 0
	for yyj165 := 0; ; yyj165++ {
		if yyhl165 {
			if yyj165 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys165Slc = r.DecodeBytes(yys165Slc, true, true)
		yys165 := string(yys165Slc)
		switch yys165 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				if x.ObservedGeneration != nil {
					x.ObservedGeneration = nil
				}
			} else {
				if x.ObservedGeneration == nil {
					x.ObservedGeneration = new(int64)
				}
				yym167 := z.DecBinary()
				_ = yym167
				if false {
				} else {
					*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
				}
			}
		case "lastScaleTime":
			if r.TryDecodeAsNil() {
				if x.LastScaleTime != nil {
					x.LastScaleTime = nil
				}
			} else {
				if x.LastScaleTime == nil {
					x.LastScaleTime = new(pkg1_unversioned.Time)
				}
				yym169 := z.DecBinary()
				_ = yym169
				if false {
				} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
				} else if yym169 {
					z.DecBinaryUnmarshal(x.LastScaleTime)
				} else if !yym169 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.LastScaleTime)
				} else {
					z.DecFallback(x.LastScaleTime, false)
				}
			}
		case "currentReplicas":
			if r.TryDecodeAsNil() {
				x.CurrentReplicas = 0
			} else {
				x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int)
				}
				yym173 := z.DecBinary()
				_ = yym173
				if false {
				} else {
					*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys165)
		} // end switch yys165
	} // end for yyj165
	if !yyhl165 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj174 int
	var yyb174 bool
	var yyhl174 bool = l >= 0
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.ObservedGeneration != nil {
			x.ObservedGeneration = nil
		}
	} else {
		if x.ObservedGeneration == nil {
			x.ObservedGeneration = new(int64)
		}
		yym176 := z.DecBinary()
		_ = yym176
		if false {
		} else {
			*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
		}
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.LastScaleTime != nil {
			x.LastScaleTime = nil
		}
	} else {
		if x.LastScaleTime == nil {
			x.LastScaleTime = new(pkg1_unversioned.Time)
		}
		yym178 := z.DecBinary()
		_ = yym178
		if false {
		} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
		} else if yym178 {
			z.DecBinaryUnmarshal(x.LastScaleTime)
		} else if !yym178 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.LastScaleTime)
		} else {
			z.DecFallback(x.LastScaleTime, false)
		}
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentReplicas = 0
	} else {
		x.CurrentReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredReplicas = 0
	} else {
		x.DesiredReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj174++
	if yyhl174 {
		yyb174 = yyj174 > l
	} else {
		yyb174 = r.CheckBreak()
	}
	if yyb174 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.CurrentCPUUtilizationPercentage != nil {
			x.CurrentCPUUtilizationPercentage = nil
		}
	} else {
		if x.CurrentCPUUtilizationPercentage == nil {
			x.CurrentCPUUtilizationPercentage = new(int)
		}
		yym182 := z.DecBinary()
		_ = yym182
		if false {
		} else {
			*((*int)(x.CurrentCPUUtilizationPercentage)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	for {
		yyj174++
		if yyhl174 {
			yyb174 = yyj174 > l
		} else {
			yyb174 = r.CheckBreak()
		}
		if yyb174 {
			break
		}
		z.DecStructFieldNotFound(yyj174-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 {
		yym183 := z.EncBinary()
		_ = yym183
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep184 := !z.EncBinary()
			yy2arr184 := z.EncBasicHandle().StructToArray
			var yyq184 [5]bool
			_, _, _ = yysep184, yyq184, yy2arr184
			const yyr184 bool = false
			yyq184[0] = x.Kind != ""
			yyq184[1] = x.APIVersion != ""
			yyq184[2] = true
			yyq184[3] = true
			yyq184[4] = true
			if yyr184 || yy2arr184 {
				r.EncodeArrayStart(5)
			} else {
				var yynn184 int = 0
				for _, b := range yyq184 {
					if b {
						yynn184++
					}
				}
				r.EncodeMapStart(yynn184)
			}
			if yyr184 || yy2arr184 {
				if yyq184[0] {
					yym186 := z.EncBinary()
					_ = yym186
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq184[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym187 := z.EncBinary()
					_ = yym187
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr184 || yy2arr184 {
				if yyq184[1] {
					yym189 := z.EncBinary()
					_ = yym189
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq184[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym190 := z.EncBinary()
					_ = yym190
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr184 || yy2arr184 {
				if yyq184[2] {
					yy192 := &x.ObjectMeta
					yy192.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy193 := &x.ObjectMeta
					yy193.CodecEncodeSelf(e)
				}
			}
			if yyr184 || yy2arr184 {
				if yyq184[3] {
					yy195 := &x.Spec
					yy195.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy196 := &x.Spec
					yy196.CodecEncodeSelf(e)
				}
			}
			if yyr184 || yy2arr184 {
				if yyq184[4] {
					yy198 := &x.Status
					yy198.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq184[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy199 := &x.Status
					yy199.CodecEncodeSelf(e)
				}
			}
			if yysep184 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys202Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys202Slc
	var yyhl202 bool = l >= 0
	for yyj202 := 0; ; yyj202++ {
		if yyhl202 {
			if yyj202 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys202Slc = r.DecodeBytes(yys202Slc, true, true)
		yys202 := string(yys202Slc)
		switch yys202 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv205 := &x.ObjectMeta
				yyv205.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = HorizontalPodAutoscalerSpec{}
			} else {
				yyv206 := &x.Spec
				yyv206.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = HorizontalPodAutoscalerStatus{}
			} else {
				yyv207 := &x.Status
				yyv207.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys202)
		} // end switch yys202
	} // end for yyj202
	if !yyhl202 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj208 int
	var yyb208 bool
	var yyhl208 bool = l >= 0
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv211 := &x.ObjectMeta
		yyv211.CodecDecodeSelf(d)
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = HorizontalPodAutoscalerSpec{}
	} else {
		yyv212 := &x.Spec
		yyv212.CodecDecodeSelf(d)
	}
	yyj208++
	if yyhl208 {
		yyb208 = yyj208 > l
	} else {
		yyb208 = r.CheckBreak()
	}
	if yyb208 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = HorizontalPodAutoscalerStatus{}
	} else {
		yyv213 := &x.Status
		yyv213.CodecDecodeSelf(d)
	}
	for {
		yyj208++
		if yyhl208 {
			yyb208 = yyj208 > l
		} else {
			yyb208 = r.CheckBreak()
		}
		if yyb208 {
			break
		}
		z.DecStructFieldNotFound(yyj208-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 {
		yym214 := z.EncBinary()
		_ = yym214
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep215 := !z.EncBinary()
			yy2arr215 := z.EncBasicHandle().StructToArray
			var yyq215 [4]bool
			_, _, _ = yysep215, yyq215, yy2arr215
			const yyr215 bool = false
			yyq215[0] = x.Kind != ""
			yyq215[1] = x.APIVersion != ""
			yyq215[2] = true
			if yyr215 || yy2arr215 {
				r.EncodeArrayStart(4)
			} else {
				var yynn215 int = 1
				for _, b := range yyq215 {
					if b {
						yynn215++
					}
				}
				r.EncodeMapStart(yynn215)
			}
			if yyr215 || yy2arr215 {
				if yyq215[0] {
					yym217 := z.EncBinary()
					_ = yym217
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq215[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym218 := z.EncBinary()
					_ = yym218
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr215 || yy2arr215 {
				if yyq215[1] {
					yym220 := z.EncBinary()
					_ = yym220
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq215[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym221 := z.EncBinary()
					_ = yym221
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr215 || yy2arr215 {
				if yyq215[2] {
					yy223 := &x.ListMeta
					yym224 := z.EncBinary()
					_ = yym224
					if false {
					} else if z.HasExtensions() && z.EncExt(yy223) {
					} else {
						z.EncFallback(yy223)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq215[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy225 := &x.ListMeta
					yym226 := z.EncBinary()
					_ = yym226
					if false {
					} else if z.HasExtensions() && z.EncExt(yy225) {
					} else {
						z.EncFallback(yy225)
					}
				}
			}
			if yyr215 || yy2arr215 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym228 := z.EncBinary()
					_ = yym228
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym229 := z.EncBinary()
					_ = yym229
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep215 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys232Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys232Slc
	var yyhl232 bool = l >= 0
	for yyj232 := 0; ; yyj232++ {
		if yyhl232 {
			if yyj232 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys232Slc = r.DecodeBytes(yys232Slc, true, true)
		yys232 := string(yys232Slc)
		switch yys232 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv235 := &x.ListMeta
				yym236 := z.DecBinary()
				_ = yym236
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv235) {
				} else {
					z.DecFallback(yyv235, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv237 := &x.Items
				yym238 := z.DecBinary()
				_ = yym238
				if false {
				} else {
					h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv237), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys232)
		} // end switch yys232
	} // end for yyj232
	if !yyhl232 {
		r.ReadEnd()
	}
}

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj239 int
	var yyb239 bool
	var yyhl239 bool = l >= 0
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv242 := &x.ListMeta
		yym243 := z.DecBinary()
		_ = yym243
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv242) {
		} else {
			z.DecFallback(yyv242, false)
		}
	}
	yyj239++
	if yyhl239 {
		yyb239 = yyj239 > l
	} else {
		yyb239 = r.CheckBreak()
	}
	if yyb239 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv244 := &x.Items
		yym245 := z.DecBinary()
		_ = yym245
		if false {
		} else {
			h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv244), d)
		}
	}
	for {
		yyj239++
		if yyhl239 {
			yyb239 = yyj239 > l
		} else {
			yyb239 = r.CheckBreak()
		}
		if yyb239 {
			break
		}
		z.DecStructFieldNotFound(yyj239-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 {
		yym246 := z.EncBinary()
		_ = yym246
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep247 := !z.EncBinary()
			yy2arr247 := z.EncBasicHandle().StructToArray
			var yyq247 [5]bool
			_, _, _ = yysep247, yyq247, yy2arr247
			const yyr247 bool = false
			yyq247[0] = x.Kind != ""
			yyq247[1] = x.APIVersion != ""
			yyq247[2] = true
			yyq247[3] = x.Description != ""
			yyq247[4] = len(x.Versions) != 0
			if yyr247 || yy2arr247 {
				r.EncodeArrayStart(5)
			} else {
				var yynn247 int = 0
				for _, b := range yyq247 {
					if b {
						yynn247++
					}
				}
				r.EncodeMapStart(yynn247)
			}
			if yyr247 || yy2arr247 {
				if yyq247[0] {
					yym249 := z.EncBinary()
					_ = yym249
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym250 := z.EncBinary()
					_ = yym250
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr247 || yy2arr247 {
				if yyq247[1] {
					yym252 := z.EncBinary()
					_ = yym252
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym253 := z.EncBinary()
					_ = yym253
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr247 || yy2arr247 {
				if yyq247[2] {
					yy255 := &x.ObjectMeta
					yy255.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq247[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy256 := &x.ObjectMeta
					yy256.CodecEncodeSelf(e)
				}
			}
			if yyr247 || yy2arr247 {
				if yyq247[3] {
					yym258 := z.EncBinary()
					_ = yym258
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq247[3] {
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					yym259 := z.EncBinary()
					_ = yym259
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr247 || yy2arr247 {
				if yyq247[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym261 := z.EncBinary()
						_ = yym261
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq247[4] {
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym262 := z.EncBinary()
						_ = yym262
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yysep247 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys265Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys265Slc
	var yyhl265 bool = l >= 0
	for yyj265 := 0; ; yyj265++ {
		if yyhl265 {
			if yyj265 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys265Slc = r.DecodeBytes(yys265Slc, true, true)
		yys265 := string(yys265Slc)
		switch yys265 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv268 := &x.ObjectMeta
				yyv268.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv270 := &x.Versions
				yym271 := z.DecBinary()
				_ = yym271
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv270), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys265)
		} // end switch yys265
	} // end for yyj265
	if !yyhl265 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj272 int
	var yyb272 bool
	var yyhl272 bool = l >= 0
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv275 := &x.ObjectMeta
		yyv275.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv277 := &x.Versions
		yym278 := z.DecBinary()
		_ = yym278
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv277), d)
		}
	}
	for {
		yyj272++
		if yyhl272 {
			yyb272 = yyj272 > l
		} else {
			yyb272 = r.CheckBreak()
		}
		if yyb272 {
			break
		}
		z.DecStructFieldNotFound(yyj272-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 {
		yym279 := z.EncBinary()
		_ = yym279
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep280 := !z.EncBinary()
			yy2arr280 := z.EncBasicHandle().StructToArray
			var yyq280 [4]bool
			_, _, _ = yysep280, yyq280, yy2arr280
			const yyr280 bool = false
			yyq280[0] = x.Kind != ""
			yyq280[1] = x.APIVersion != ""
			yyq280[2] = true
			if yyr280 || yy2arr280 {
				r.EncodeArrayStart(4)
			} else {
				var yynn280 int = 1
				for _, b := range yyq280 {
					if b {
						yynn280++
					}
				}
				r.EncodeMapStart(yynn280)
			}
			if yyr280 || yy2arr280 {
				if yyq280[0] {
					yym282 := z.EncBinary()
					_ = yym282
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq280[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym283 := z.EncBinary()
					_ = yym283
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr280 || yy2arr280 {
				if yyq280[1] {
					yym285 := z.EncBinary()
					_ = yym285
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq280[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym286 := z.EncBinary()
					_ = yym286
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr280 || yy2arr280 {
				if yyq280[2] {
					yy288 := &x.ListMeta
					yym289 := z.EncBinary()
					_ = yym289
					if false {
					} else if z.HasExtensions() && z.EncExt(yy288) {
					} else {
						z.EncFallback(yy288)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq280[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy290 := &x.ListMeta
					yym291 := z.EncBinary()
					_ = yym291
					if false {
					} else if z.HasExtensions() && z.EncExt(yy290) {
					} else {
						z.EncFallback(yy290)
					}
				}
			}
			if yyr280 || yy2arr280 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym293 := z.EncBinary()
					_ = yym293
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yysep280 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys297Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys297Slc
	var yyhl297 bool = l >= 0
	for yyj297 := 0; ; yyj297++ {
		if yyhl297 {
			if yyj297 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys297Slc = r.DecodeBytes(yys297Slc, true, true)
		yys297 := string(yys297Slc)
		switch yys297 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv300 := &x.ListMeta
				yym301 := z.DecBinary()
				_ = yym301
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv300) {
				} else {
					z.DecFallback(yyv300, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv302 := &x.Items
				yym303 := z.DecBinary()
				_ = yym303
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv302), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys297)
		} // end switch yys297
	} // end for yyj297
	if !yyhl297 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj304 int
	var yyb304 bool
	var yyhl304 bool = l >= 0
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv307 := &x.ListMeta
		yym308 := z.DecBinary()
		_ = yym308
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv307) {
		} else {
			z.DecFallback(yyv307, false)
		}
	}
	yyj304++
	if yyhl304 {
		yyb304 = yyj304 > l
	} else {
		yyb304 = r.CheckBreak()
	}
	if yyb304 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv309 := &x.Items
		yym310 := z.DecBinary()
		_ = yym310
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv309), d)
		}
	}
	for {
		yyj304++
		if yyhl304 {
			yyb304 = yyj304 > l
		} else {
			yyb304 = r.CheckBreak()
		}
		if yyb304 {
			break
		}
		z.DecStructFieldNotFound(yyj304-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 {
		yym311 := z.EncBinary()
		_ = yym311
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep312 := !z.EncBinary()
			yy2arr312 := z.EncBasicHandle().StructToArray
			var yyq312 [2]bool
			_, _, _ = yysep312, yyq312, yy2arr312
			const yyr312 bool = false
			yyq312[0] = x.Name != ""
			yyq312[1] = x.APIGroup != ""
			if yyr312 || yy2arr312 {
				r.EncodeArrayStart(2)
			} else {
				var yynn312 int = 0
				for _, b := range yyq312 {
					if b {
						yynn312++
					}
				}
				r.EncodeMapStart(yynn312)
			}
			if yyr312 || yy2arr312 {
				if yyq312[0] {
					yym314 := z.EncBinary()
					_ = yym314
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq312[0] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					yym315 := z.EncBinary()
					_ = yym315
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr312 || yy2arr312 {
				if yyq312[1] {
					yym317 := z.EncBinary()
					_ = yym317
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq312[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiGroup"))
					yym318 := z.EncBinary()
					_ = yym318
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIGroup))
					}
				}
			}
			if yysep312 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *APIVersion) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys321Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys321Slc
	var yyhl321 bool = l >= 0
	for yyj321 := 0; ; yyj321++ {
		if yyhl321 {
			if yyj321 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys321Slc = r.DecodeBytes(yys321Slc, true, true)
		yys321 := string(yys321Slc)
		switch yys321 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "apiGroup":
			if r.TryDecodeAsNil() {
				x.APIGroup = ""
			} else {
				x.APIGroup = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys321)
		} // end switch yys321
	} // end for yyj321
	if !yyhl321 {
		r.ReadEnd()
	}
}

func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj324 int
	var yyb324 bool
	var yyhl324 bool = l >= 0
	yyj324++
	if yyhl324 {
		yyb324 = yyj324 > l
	} else {
		yyb324 = r.CheckBreak()
	}
	if yyb324 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj324++
	if yyhl324 {
		yyb324 = yyj324 > l
	} else {
		yyb324 = r.CheckBreak()
	}
	if yyb324 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIGroup = ""
	} else {
		x.APIGroup = string(r.DecodeString())
	}
	for {
		yyj324++
		if yyhl324 {
			yyb324 = yyj324 > l
		} else {
			yyb324 = r.CheckBreak()
		}
		if yyb324 {
			break
		}
		z.DecStructFieldNotFound(yyj324-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 {
		yym327 := z.EncBinary()
		_ = yym327
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep328 := !z.EncBinary()
			yy2arr328 := z.EncBasicHandle().StructToArray
			var yyq328 [4]bool
			_, _, _ = yysep328, yyq328, yy2arr328
			const yyr328 bool = false
			yyq328[0] = x.Kind != ""
			yyq328[1] = x.APIVersion != ""
			yyq328[2] = true
			yyq328[3] = len(x.Data) != 0
			if yyr328 || yy2arr328 {
				r.EncodeArrayStart(4)
			} else {
				var yynn328 int = 0
				for _, b := range yyq328 {
					if b {
						yynn328++
					}
				}
				r.EncodeMapStart(yynn328)
			}
			if yyr328 || yy2arr328 {
				if yyq328[0] {
					yym330 := z.EncBinary()
					_ = yym330
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq328[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym331 := z.EncBinary()
					_ = yym331
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr328 || yy2arr328 {
				if yyq328[1] {
					yym333 := z.EncBinary()
					_ = yym333
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq328[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym334 := z.EncBinary()
					_ = yym334
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr328 || yy2arr328 {
				if yyq328[2] {
					yy336 := &x.ObjectMeta
					yy336.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq328[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy337 := &x.ObjectMeta
					yy337.CodecEncodeSelf(e)
				}
			}
			if yyr328 || yy2arr328 {
				if yyq328[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym339 := z.EncBinary()
						_ = yym339
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq328[3] {
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym340 := z.EncBinary()
						_ = yym340
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yysep328 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceData) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys343Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys343Slc
	var yyhl343 bool = l >= 0
	for yyj343 := 0; ; yyj343++ {
		if yyhl343 {
			if yyj343 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys343Slc = r.DecodeBytes(yys343Slc, true, true)
		yys343 := string(yys343Slc)
		switch yys343 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv346 := &x.ObjectMeta
				yyv346.CodecDecodeSelf(d)
			}
		case "name":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv347 := &x.Data
				yym348 := z.DecBinary()
				_ = yym348
				if false {
				} else {
					*yyv347 = r.DecodeBytes(*(*[]byte)(yyv347), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys343)
		} // end switch yys343
	} // end for yyj343
	if !yyhl343 {
		r.ReadEnd()
	}
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj349 int
	var yyb349 bool
	var yyhl349 bool = l >= 0
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv352 := &x.ObjectMeta
		yyv352.CodecDecodeSelf(d)
	}
	yyj349++
	if yyhl349 {
		yyb349 = yyj349 > l
	} else {
		yyb349 = r.CheckBreak()
	}
	if yyb349 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv353 := &x.Data
		yym354 := z.DecBinary()
		_ = yym354
		if false {
		} else {
			*yyv353 = r.DecodeBytes(*(*[]byte)(yyv353), false, false)
		}
	}
	for {
		yyj349++
		if yyhl349 {
			yyb349 = yyj349 > l
		} else {
			yyb349 = r.CheckBreak()
		}
		if yyb349 {
			break
		}
		z.DecStructFieldNotFound(yyj349-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 {
		yym355 := z.EncBinary()
		_ = yym355
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep356 := !z.EncBinary()
			yy2arr356 := z.EncBasicHandle().StructToArray
			var yyq356 [5]bool
			_, _, _ = yysep356, yyq356, yy2arr356
			const yyr356 bool = false
			yyq356[0] = x.Kind != ""
			yyq356[1] = x.APIVersion != ""
			yyq356[2] = true
			yyq356[3] = true
			yyq356[4] = true
			if yyr356 || yy2arr356 {
				r.EncodeArrayStart(5)
			} else {
				var yynn356 int = 0
				for _, b := range yyq356 {
					if b {
						yynn356++
					}
				}
				r.EncodeMapStart(yynn356)
			}
			if yyr356 || yy2arr356 {
				if yyq356[0] {
					yym358 := z.EncBinary()
					_ = yym358
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq356[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym359 := z.EncBinary()
					_ = yym359
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr356 || yy2arr356 {
				if yyq356[1] {
					yym361 := z.EncBinary()
					_ = yym361
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq356[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym362 := z.EncBinary()
					_ = yym362
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr356 || yy2arr356 {
				if yyq356[2] {
					yy364 := &x.ObjectMeta
					yy364.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy365 := &x.ObjectMeta
					yy365.CodecEncodeSelf(e)
				}
			}
			if yyr356 || yy2arr356 {
				if yyq356[3] {
					yy367 := &x.Spec
					yy367.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy368 := &x.Spec
					yy368.CodecEncodeSelf(e)
				}
			}
			if yyr356 || yy2arr356 {
				if yyq356[4] {
					yy370 := &x.Status
					yy370.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq356[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy371 := &x.Status
					yy371.CodecEncodeSelf(e)
				}
			}
			if yysep356 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys374Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys374Slc
	var yyhl374 bool = l >= 0
	for yyj374 := 0; ; yyj374++ {
		if yyhl374 {
			if yyj374 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys374Slc = r.DecodeBytes(yys374Slc, true, true)
		yys374 := string(yys374Slc)
		switch yys374 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv377 := &x.ObjectMeta
				yyv377.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv378 := &x.Spec
				yyv378.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv379 := &x.Status
				yyv379.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys374)
		} // end switch yys374
	} // end for yyj374
	if !yyhl374 {
		r.ReadEnd()
	}
}

func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj380 int
	var yyb380 bool
	var yyhl380 bool = l >= 0
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv383 := &x.ObjectMeta
		yyv383.CodecDecodeSelf(d)
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv384 := &x.Spec
		yyv384.CodecDecodeSelf(d)
	}
	yyj380++
	if yyhl380 {
		yyb380 = yyj380 > l
	} else {
		yyb380 = r.CheckBreak()
	}
	if yyb380 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv385 := &x.Status
		yyv385.CodecDecodeSelf(d)
	}
	for {
		yyj380++
		if yyhl380 {
			yyb380 = yyj380 > l
		} else {
			yyb380 = r.CheckBreak()
		}
		if yyb380 {
			break
		}
		z.DecStructFieldNotFound(yyj380-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 {
		yym386 := z.EncBinary()
		_ = yym386
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep387 := !z.EncBinary()
			yy2arr387 := z.EncBasicHandle().StructToArray
			var yyq387 [5]bool
			_, _, _ = yysep387, yyq387, yy2arr387
			const yyr387 bool = false
			yyq387[0] = x.Replicas != nil
			yyq387[1] = len(x.Selector) != 0
			yyq387[3] = true
			yyq387[4] = x.UniqueLabelKey != nil
			if yyr387 || yy2arr387 {
				r.EncodeArrayStart(5)
			} else {
				var yynn387 int = 1
				for _, b := range yyq387 {
					if b {
						yynn387++
					}
				}
				r.EncodeMapStart(yynn387)
			}
			if yyr387 || yy2arr387 {
				if yyq387[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy389 := *x.Replicas
						yym390 := z.EncBinary()
						_ = yym390
						if false {
						} else {
							r.EncodeInt(int64(yy389))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy391 := *x.Replicas
						yym392 := z.EncBinary()
						_ = yym392
						if false {
						} else {
							r.EncodeInt(int64(yy391))
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				if yyq387[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym394 := z.EncBinary()
						_ = yym394
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[1] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym395 := z.EncBinary()
						_ = yym395
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				yy397 := &x.Template
				yy397.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy398 := &x.Template
				yy398.CodecEncodeSelf(e)
			}
			if yyr387 || yy2arr387 {
				if yyq387[3] {
					yy400 := &x.Strategy
					yy400.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[3] {
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					yy401 := &x.Strategy
					yy401.CodecEncodeSelf(e)
				}
			}
			if yyr387 || yy2arr387 {
				if yyq387[4] {
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy403 := *x.UniqueLabelKey
						yym404 := z.EncBinary()
						_ = yym404
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy403))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[4] {
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					if x.UniqueLabelKey == nil {
						r.EncodeNil()
					} else {
						yy405 := *x.UniqueLabelKey
						yym406 := z.EncBinary()
						_ = yym406
						if false {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy405))
						}
					}
				}
			}
			if yysep387 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj418 int
	var yyb418 bool
	var yyhl418 bool = l >= 0
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int)
		}
		yym420 := z.DecBinary()
		_ = yym420
		if false {
		} else {
			*((*int)(x.Replicas)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv421 := &x.Selector
		yym422 := z.DecBinary()
		_ = yym422
		if false {
		} else {
			z.F.DecMapStringStringX(yyv421, false, d)
		}
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv423 := &x.Template
		yyv423.CodecDecodeSelf(d)
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv424 := &x.Strategy
		yyv424.CodecDecodeSelf(d)
	}
	yyj418++
	if yyhl418 {
		yyb418 = yyj418 > l
	} else {
		yyb418 = r.CheckBreak()
	}
	if yyb418 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.UniqueLabelKey != nil {
			x.UniqueLabelKey = nil
		}
	} else {
		if x.UniqueLabelKey == nil {
			x.UniqueLabelKey = new(string)
		}
		yym426 := z.DecBinary()
		_ = yym426
		if false {
		} else {
			*((*string)(x.UniqueLabelKey)) = r.DecodeString()
		}
	}
	for {
		yyj418++
		if yyhl418 {
			yyb418 = yyj418 > l
		} else {
			yyb418 = r.CheckBreak()
		}
		if yyb418 {
			break
		}
		z.DecStructFieldNotFound(yyj418-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 {
		yym427 := z.EncBinary()
		_ = yym427
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep428 := !z.EncBinary()
			yy2arr428 := z.EncBasicHandle().StructToArray
			var yyq428 [2]bool
			_, _, _ = yysep428, yyq428, yy2arr428
			const yyr428 bool = false
			yyq428[0] = x.Type != ""
			yyq428[1] = x.RollingUpdate != nil
			if yyr428 || yy2arr428 {
				r.EncodeArrayStart(2)
			} else {
				var yynn428 int = 0
				for _, b := range yyq428 {
					if b {
						yynn428++
					}
				}
				r.EncodeMapStart(yynn428)
			}
			if yyr428 || yy2arr428 {
				if yyq428[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq428[0] {
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr428 || yy2arr428 {
				if yyq428[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq428[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yysep428 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj460 int
	var yyb460 bool
	var yyhl460 bool = l >= 0
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg6_util.IntOrString)
		}
		yym462 := z.DecBinary()
		_ = yym462
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym462 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg6_util.IntOrString)
		}
		yym464 := z.DecBinary()
		_ = yym464
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym464 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	yyj460++
	if yyhl460 {
		yyb460 = yyj460 > l
	} else {
		yyb460 = r.CheckBreak()
	}
	if yyb460 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj460++
		if yyhl460 {
			yyb460 = yyj460 > l
		} else {
			yyb460 = r.CheckBreak()
		}
		if yyb460 {
			break
		}
		z.DecStructFieldNotFound(yyj460-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 {
		yym466 := z.EncBinary()
		_ = yym466
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep467 := !z.EncBinary()
			yy2arr467 := z.EncBasicHandle().StructToArray
			var yyq467 [2]bool
			_, _, _ = yysep467, yyq467, yy2arr467
			const yyr467 bool = false
			yyq467[0] = x.Replicas != 0
			yyq467[1] = x.UpdatedReplicas != 0
			if yyr467 || yy2arr467 {
				r.EncodeArrayStart(2)
			} else {
				var yynn467 int = 0
				for _, b := range yyq467 {
					if b {
						yynn467++
					}
				}
				r.EncodeMapStart(yynn467)
			}
			if yyr467 || yy2arr467 {
				if yyq467[0] {
					yym469 := z.EncBinary()
					_ = yym469
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq467[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym470 := z.EncBinary()
					_ = yym470
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr467 || yy2arr467 {
				if yyq467[1] {
					yym472 := z.EncBinary()
					_ = yym472
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq467[1] {
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					yym473 := z.EncBinary()
					_ = yym473
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yysep467 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj479 int
	var yyb479 bool
	var yyhl479 bool = l >= 0
	yyj479++
	if yyhl479 {
		yyb479 = yyj479 > l
	} else {
		yyb479 = r.CheckBreak()
	}
	if yyb479 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj479++
	if yyhl479 {
		yyb479 = yyj479 > l
	} else {
		yyb479 = r.CheckBreak()
	}
	if yyb479 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj479++
		if yyhl479 {
			yyb479 = yyj479 > l
		} else {
			yyb479 = r.CheckBreak()
		}
		if yyb479 {
			break
		}
		z.DecStructFieldNotFound(yyj479-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 {
		yym482 := z.EncBinary()
		_ = yym482
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep483 := !z.EncBinary()
			yy2arr483 := z.EncBasicHandle().StructToArray
			var yyq483 [4]bool
			_, _, _ = yysep483, yyq483, yy2arr483
			const yyr483 bool = false
			yyq483[0] = x.Kind != ""
			yyq483[1] = x.APIVersion != ""
			yyq483[2] = true
			if yyr483 || yy2arr483 {
				r.EncodeArrayStart(4)
			} else {
				var yynn483 int = 1
				for _, b := range yyq483 {
					if b {
						yynn483++
					}
				}
				r.EncodeMapStart(yynn483)
			}
			if yyr483 || yy2arr483 {
				if yyq483[0] {
					yym485 := z.EncBinary()
					_ = yym485
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq483[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym486 := z.EncBinary()
					_ = yym486
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr483 || yy2arr483 {
				if yyq483[1] {
					yym488 := z.EncBinary()
					_ = yym488
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq483[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym489 := z.EncBinary()
					_ = yym489
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr483 || yy2arr483 {
				if yyq483[2] {
					yy491 := &x.ListMeta
					yym492 := z.EncBinary()
					_ = yym492
					if false {
					} else if z.HasExtensions() && z.EncExt(yy491) {
					} else {
						z.EncFallback(yy491)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq483[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy493 := &x.ListMeta
					yym494 := z.EncBinary()
					_ = yym494
					if false {
					} else if z.HasExtensions() && z.EncExt(yy493) {
					} else {
						z.EncFallback(yy493)
					}
				}
			}
			if yyr483 || yy2arr483 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym496 := z.EncBinary()
					_ = yym496
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym497 := z.EncBinary()
					_ = yym497
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yysep483 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj507 int
	var yyb507 bool
	var yyhl507 bool = l >= 0
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv510 := &x.ListMeta
		yym511 := z.DecBinary()
		_ = yym511
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv510) {
		} else {
			z.DecFallback(yyv510, false)
		}
	}
	yyj507++
	if yyhl507 {
		yyb507 = yyj507 > l
	} else {
		yyb507 = r.CheckBreak()
	}
	if yyb507 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv512 := &x.Items
		yym513 := z.DecBinary()
		_ = yym513
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv512), d)
		}
	}
	for {
		yyj507++
		if yyhl507 {
			yyb507 = yyj507 > l
		} else {
			yyb507 = r.CheckBreak()
		}
		if yyb507 {
			break
		}
		z.DecStructFieldNotFound(yyj507-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 {
		yym514 := z.EncBinary()
		_ = yym514
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep515 := !z.EncBinary()
			yy2arr515 := z.EncBasicHandle().StructToArray
			var yyq515 [2]bool
			_, _, _ = yysep515, yyq515, yy2arr515
			const yyr515 bool = false
			yyq515[0] = len(x.Selector) != 0
			yyq515[1] = x.Template != nil
			if yyr515 || yy2arr515 {
				r.EncodeArrayStart(2)
			} else {
				var yynn515 int = 0
				for _, b := range yyq515 {
					if b {
						yynn515++
					}
				}
				r.EncodeMapStart(yynn515)
			}
			if yyr515 || yy2arr515 {
				if yyq515[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym517 := z.EncBinary()
						_ = yym517
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq515[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym518 := z.EncBinary()
						_ = yym518
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr515 || yy2arr515 {
				if yyq515[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq515[1] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yysep515 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj526 int
	var yyb526 bool
	var yyhl526 bool = l >= 0
	yyj526++
	if yyhl526 {
		yyb526 = yyj526 > l
	} else {
		yyb526 = r.CheckBreak()
	}
	if yyb526 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv527 := &x.Selector
		yym528 := z.DecBinary()
		_ = yym528
		if false {
		} else {
			z.F.DecMapStringStringX(yyv527, false, d)
		}
	}
	yyj526++
	if yyhl526 {
		yyb526 = yyj526 > l
	} else {
		yyb526 = r.CheckBreak()
	}
	if yyb526 {
		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 {
		yyj526++
		if yyhl526 {
			yyb526 = yyj526 > l
		} else {
			yyb526 = r.CheckBreak()
		}
		if yyb526 {
			break
		}
		z.DecStructFieldNotFound(yyj526-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 {
		yym530 := z.EncBinary()
		_ = yym530
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep531 := !z.EncBinary()
			yy2arr531 := z.EncBasicHandle().StructToArray
			var yyq531 [3]bool
			_, _, _ = yysep531, yyq531, yy2arr531
			const yyr531 bool = false
			if yyr531 || yy2arr531 {
				r.EncodeArrayStart(3)
			} else {
				var yynn531 int = 3
				for _, b := range yyq531 {
					if b {
						yynn531++
					}
				}
				r.EncodeMapStart(yynn531)
			}
			if yyr531 || yy2arr531 {
				yym533 := z.EncBinary()
				_ = yym533
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym534 := z.EncBinary()
				_ = yym534
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr531 || yy2arr531 {
				yym536 := z.EncBinary()
				_ = yym536
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym537 := z.EncBinary()
				_ = yym537
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr531 || yy2arr531 {
				yym539 := z.EncBinary()
				_ = yym539
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym540 := z.EncBinary()
				_ = yym540
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep531 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj576 int
	var yyb576 bool
	var yyhl576 bool = l >= 0
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv579 := &x.ObjectMeta
		yyv579.CodecDecodeSelf(d)
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv580 := &x.Spec
		yyv580.CodecDecodeSelf(d)
	}
	yyj576++
	if yyhl576 {
		yyb576 = yyj576 > l
	} else {
		yyb576 = r.CheckBreak()
	}
	if yyb576 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv581 := &x.Status
		yyv581.CodecDecodeSelf(d)
	}
	for {
		yyj576++
		if yyhl576 {
			yyb576 = yyj576 > l
		} else {
			yyb576 = r.CheckBreak()
		}
		if yyb576 {
			break
		}
		z.DecStructFieldNotFound(yyj576-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 {
		yym582 := z.EncBinary()
		_ = yym582
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep583 := !z.EncBinary()
			yy2arr583 := z.EncBasicHandle().StructToArray
			var yyq583 [4]bool
			_, _, _ = yysep583, yyq583, yy2arr583
			const yyr583 bool = false
			yyq583[0] = x.Kind != ""
			yyq583[1] = x.APIVersion != ""
			yyq583[2] = true
			if yyr583 || yy2arr583 {
				r.EncodeArrayStart(4)
			} else {
				var yynn583 int = 1
				for _, b := range yyq583 {
					if b {
						yynn583++
					}
				}
				r.EncodeMapStart(yynn583)
			}
			if yyr583 || yy2arr583 {
				if yyq583[0] {
					yym585 := z.EncBinary()
					_ = yym585
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq583[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr583 || yy2arr583 {
				if yyq583[1] {
					yym588 := z.EncBinary()
					_ = yym588
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq583[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr583 || yy2arr583 {
				if yyq583[2] {
					yy591 := &x.ListMeta
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else if z.HasExtensions() && z.EncExt(yy591) {
					} else {
						z.EncFallback(yy591)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq583[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy593 := &x.ListMeta
					yym594 := z.EncBinary()
					_ = yym594
					if false {
					} else if z.HasExtensions() && z.EncExt(yy593) {
					} else {
						z.EncFallback(yy593)
					}
				}
			}
			if yyr583 || yy2arr583 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym596 := z.EncBinary()
					_ = yym596
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym597 := z.EncBinary()
					_ = yym597
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep583 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj607 int
	var yyb607 bool
	var yyhl607 bool = l >= 0
	yyj607++
	if yyhl607 {
		yyb607 = yyj607 > l
	} else {
		yyb607 = r.CheckBreak()
	}
	if yyb607 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj607++
	if yyhl607 {
		yyb607 = yyj607 > l
	} else {
		yyb607 = r.CheckBreak()
	}
	if yyb607 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj607++
	if yyhl607 {
		yyb607 = yyj607 > l
	} else {
		yyb607 = r.CheckBreak()
	}
	if yyb607 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv610 := &x.ListMeta
		yym611 := z.DecBinary()
		_ = yym611
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv610) {
		} else {
			z.DecFallback(yyv610, false)
		}
	}
	yyj607++
	if yyhl607 {
		yyb607 = yyj607 > l
	} else {
		yyb607 = r.CheckBreak()
	}
	if yyb607 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv612 := &x.Items
		yym613 := z.DecBinary()
		_ = yym613
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv612), d)
		}
	}
	for {
		yyj607++
		if yyhl607 {
			yyb607 = yyj607 > l
		} else {
			yyb607 = r.CheckBreak()
		}
		if yyb607 {
			break
		}
		z.DecStructFieldNotFound(yyj607-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 {
		yym614 := z.EncBinary()
		_ = yym614
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep615 := !z.EncBinary()
			yy2arr615 := z.EncBasicHandle().StructToArray
			var yyq615 [4]bool
			_, _, _ = yysep615, yyq615, yy2arr615
			const yyr615 bool = false
			yyq615[0] = x.Kind != ""
			yyq615[1] = x.APIVersion != ""
			yyq615[2] = true
			if yyr615 || yy2arr615 {
				r.EncodeArrayStart(4)
			} else {
				var yynn615 int = 1
				for _, b := range yyq615 {
					if b {
						yynn615++
					}
				}
				r.EncodeMapStart(yynn615)
			}
			if yyr615 || yy2arr615 {
				if yyq615[0] {
					yym617 := z.EncBinary()
					_ = yym617
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq615[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr615 || yy2arr615 {
				if yyq615[1] {
					yym620 := z.EncBinary()
					_ = yym620
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq615[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr615 || yy2arr615 {
				if yyq615[2] {
					yy623 := &x.ListMeta
					yym624 := z.EncBinary()
					_ = yym624
					if false {
					} else if z.HasExtensions() && z.EncExt(yy623) {
					} else {
						z.EncFallback(yy623)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq615[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy625 := &x.ListMeta
					yym626 := z.EncBinary()
					_ = yym626
					if false {
					} else if z.HasExtensions() && z.EncExt(yy625) {
					} else {
						z.EncFallback(yy625)
					}
				}
			}
			if yyr615 || yy2arr615 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym628 := z.EncBinary()
					_ = yym628
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym629 := z.EncBinary()
					_ = yym629
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep615 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj639 int
	var yyb639 bool
	var yyhl639 bool = l >= 0
	yyj639++
	if yyhl639 {
		yyb639 = yyj639 > l
	} else {
		yyb639 = r.CheckBreak()
	}
	if yyb639 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj639++
	if yyhl639 {
		yyb639 = yyj639 > l
	} else {
		yyb639 = r.CheckBreak()
	}
	if yyb639 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj639++
	if yyhl639 {
		yyb639 = yyj639 > l
	} else {
		yyb639 = r.CheckBreak()
	}
	if yyb639 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv642 := &x.ListMeta
		yym643 := z.DecBinary()
		_ = yym643
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv642) {
		} else {
			z.DecFallback(yyv642, false)
		}
	}
	yyj639++
	if yyhl639 {
		yyb639 = yyj639 > l
	} else {
		yyb639 = r.CheckBreak()
	}
	if yyb639 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv644 := &x.Items
		yym645 := z.DecBinary()
		_ = yym645
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv644), d)
		}
	}
	for {
		yyj639++
		if yyhl639 {
			yyb639 = yyj639 > l
		} else {
			yyb639 = r.CheckBreak()
		}
		if yyb639 {
			break
		}
		z.DecStructFieldNotFound(yyj639-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 {
		yym646 := z.EncBinary()
		_ = yym646
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep647 := !z.EncBinary()
			yy2arr647 := z.EncBasicHandle().StructToArray
			var yyq647 [5]bool
			_, _, _ = yysep647, yyq647, yy2arr647
			const yyr647 bool = false
			yyq647[0] = x.Kind != ""
			yyq647[1] = x.APIVersion != ""
			yyq647[2] = true
			yyq647[3] = true
			yyq647[4] = true
			if yyr647 || yy2arr647 {
				r.EncodeArrayStart(5)
			} else {
				var yynn647 int = 0
				for _, b := range yyq647 {
					if b {
						yynn647++
					}
				}
				r.EncodeMapStart(yynn647)
			}
			if yyr647 || yy2arr647 {
				if yyq647[0] {
					yym649 := z.EncBinary()
					_ = yym649
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq647[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym650 := z.EncBinary()
					_ = yym650
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr647 || yy2arr647 {
				if yyq647[1] {
					yym652 := z.EncBinary()
					_ = yym652
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq647[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr647 || yy2arr647 {
				if yyq647[2] {
					yy655 := &x.ObjectMeta
					yy655.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq647[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy656 := &x.ObjectMeta
					yy656.CodecEncodeSelf(e)
				}
			}
			if yyr647 || yy2arr647 {
				if yyq647[3] {
					yy658 := &x.Spec
					yy658.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq647[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy659 := &x.Spec
					yy659.CodecEncodeSelf(e)
				}
			}
			if yyr647 || yy2arr647 {
				if yyq647[4] {
					yy661 := &x.Status
					yy661.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq647[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy662 := &x.Status
					yy662.CodecEncodeSelf(e)
				}
			}
			if yysep647 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj671 int
	var yyb671 bool
	var yyhl671 bool = l >= 0
	yyj671++
	if yyhl671 {
		yyb671 = yyj671 > l
	} else {
		yyb671 = r.CheckBreak()
	}
	if yyb671 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj671++
	if yyhl671 {
		yyb671 = yyj671 > l
	} else {
		yyb671 = r.CheckBreak()
	}
	if yyb671 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj671++
	if yyhl671 {
		yyb671 = yyj671 > l
	} else {
		yyb671 = r.CheckBreak()
	}
	if yyb671 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv674 := &x.ObjectMeta
		yyv674.CodecDecodeSelf(d)
	}
	yyj671++
	if yyhl671 {
		yyb671 = yyj671 > l
	} else {
		yyb671 = r.CheckBreak()
	}
	if yyb671 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv675 := &x.Spec
		yyv675.CodecDecodeSelf(d)
	}
	yyj671++
	if yyhl671 {
		yyb671 = yyj671 > l
	} else {
		yyb671 = r.CheckBreak()
	}
	if yyb671 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv676 := &x.Status
		yyv676.CodecDecodeSelf(d)
	}
	for {
		yyj671++
		if yyhl671 {
			yyb671 = yyj671 > l
		} else {
			yyb671 = r.CheckBreak()
		}
		if yyb671 {
			break
		}
		z.DecStructFieldNotFound(yyj671-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 {
		yym677 := z.EncBinary()
		_ = yym677
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep678 := !z.EncBinary()
			yy2arr678 := z.EncBasicHandle().StructToArray
			var yyq678 [4]bool
			_, _, _ = yysep678, yyq678, yy2arr678
			const yyr678 bool = false
			yyq678[0] = x.Kind != ""
			yyq678[1] = x.APIVersion != ""
			yyq678[2] = true
			if yyr678 || yy2arr678 {
				r.EncodeArrayStart(4)
			} else {
				var yynn678 int = 1
				for _, b := range yyq678 {
					if b {
						yynn678++
					}
				}
				r.EncodeMapStart(yynn678)
			}
			if yyr678 || yy2arr678 {
				if yyq678[0] {
					yym680 := z.EncBinary()
					_ = yym680
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq678[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym681 := z.EncBinary()
					_ = yym681
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr678 || yy2arr678 {
				if yyq678[1] {
					yym683 := z.EncBinary()
					_ = yym683
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq678[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym684 := z.EncBinary()
					_ = yym684
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr678 || yy2arr678 {
				if yyq678[2] {
					yy686 := &x.ListMeta
					yym687 := z.EncBinary()
					_ = yym687
					if false {
					} else if z.HasExtensions() && z.EncExt(yy686) {
					} else {
						z.EncFallback(yy686)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq678[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy688 := &x.ListMeta
					yym689 := z.EncBinary()
					_ = yym689
					if false {
					} else if z.HasExtensions() && z.EncExt(yy688) {
					} else {
						z.EncFallback(yy688)
					}
				}
			}
			if yyr678 || yy2arr678 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym691 := z.EncBinary()
					_ = yym691
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym692 := z.EncBinary()
					_ = yym692
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep678 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj702 int
	var yyb702 bool
	var yyhl702 bool = l >= 0
	yyj702++
	if yyhl702 {
		yyb702 = yyj702 > l
	} else {
		yyb702 = r.CheckBreak()
	}
	if yyb702 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj702++
	if yyhl702 {
		yyb702 = yyj702 > l
	} else {
		yyb702 = r.CheckBreak()
	}
	if yyb702 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj702++
	if yyhl702 {
		yyb702 = yyj702 > l
	} else {
		yyb702 = r.CheckBreak()
	}
	if yyb702 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv705 := &x.ListMeta
		yym706 := z.DecBinary()
		_ = yym706
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv705) {
		} else {
			z.DecFallback(yyv705, false)
		}
	}
	yyj702++
	if yyhl702 {
		yyb702 = yyj702 > l
	} else {
		yyb702 = r.CheckBreak()
	}
	if yyb702 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv707 := &x.Items
		yym708 := z.DecBinary()
		_ = yym708
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv707), d)
		}
	}
	for {
		yyj702++
		if yyhl702 {
			yyb702 = yyj702 > l
		} else {
			yyb702 = r.CheckBreak()
		}
		if yyb702 {
			break
		}
		z.DecStructFieldNotFound(yyj702-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 {
		yym709 := z.EncBinary()
		_ = yym709
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep710 := !z.EncBinary()
			yy2arr710 := z.EncBasicHandle().StructToArray
			var yyq710 [4]bool
			_, _, _ = yysep710, yyq710, yy2arr710
			const yyr710 bool = false
			yyq710[0] = x.Parallelism != nil
			yyq710[1] = x.Completions != nil
			yyq710[2] = x.Selector != nil
			if yyr710 || yy2arr710 {
				r.EncodeArrayStart(4)
			} else {
				var yynn710 int = 1
				for _, b := range yyq710 {
					if b {
						yynn710++
					}
				}
				r.EncodeMapStart(yynn710)
			}
			if yyr710 || yy2arr710 {
				if yyq710[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy712 := *x.Parallelism
						yym713 := z.EncBinary()
						_ = yym713
						if false {
						} else {
							r.EncodeInt(int64(yy712))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq710[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy714 := *x.Parallelism
						yym715 := z.EncBinary()
						_ = yym715
						if false {
						} else {
							r.EncodeInt(int64(yy714))
						}
					}
				}
			}
			if yyr710 || yy2arr710 {
				if yyq710[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy717 := *x.Completions
						yym718 := z.EncBinary()
						_ = yym718
						if false {
						} else {
							r.EncodeInt(int64(yy717))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq710[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy719 := *x.Completions
						yym720 := z.EncBinary()
						_ = yym720
						if false {
						} else {
							r.EncodeInt(int64(yy719))
						}
					}
				}
			}
			if yyr710 || yy2arr710 {
				if yyq710[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq710[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr710 || yy2arr710 {
				yy723 := &x.Template
				yy723.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy724 := &x.Template
				yy724.CodecEncodeSelf(e)
			}
			if yysep710 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym783 := z.EncBinary()
	_ = yym783
	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
	yym784 := z.DecBinary()
	_ = yym784
	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 {
		yym785 := z.EncBinary()
		_ = yym785
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep786 := !z.EncBinary()
			yy2arr786 := z.EncBasicHandle().StructToArray
			var yyq786 [6]bool
			_, _, _ = yysep786, yyq786, yy2arr786
			const yyr786 bool = false
			yyq786[2] = true
			yyq786[3] = true
			yyq786[4] = x.Reason != ""
			yyq786[5] = x.Message != ""
			if yyr786 || yy2arr786 {
				r.EncodeArrayStart(6)
			} else {
				var yynn786 int = 2
				for _, b := range yyq786 {
					if b {
						yynn786++
					}
				}
				r.EncodeMapStart(yynn786)
			}
			if yyr786 || yy2arr786 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr786 || yy2arr786 {
				yym789 := z.EncBinary()
				_ = yym789
				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"))
				yym790 := z.EncBinary()
				_ = yym790
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr786 || yy2arr786 {
				if yyq786[2] {
					yy792 := &x.LastProbeTime
					yym793 := z.EncBinary()
					_ = yym793
					if false {
					} else if z.HasExtensions() && z.EncExt(yy792) {
					} else if yym793 {
						z.EncBinaryMarshal(yy792)
					} else if !yym793 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy792)
					} else {
						z.EncFallback(yy792)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq786[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy794 := &x.LastProbeTime
					yym795 := z.EncBinary()
					_ = yym795
					if false {
					} else if z.HasExtensions() && z.EncExt(yy794) {
					} else if yym795 {
						z.EncBinaryMarshal(yy794)
					} else if !yym795 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy794)
					} else {
						z.EncFallback(yy794)
					}
				}
			}
			if yyr786 || yy2arr786 {
				if yyq786[3] {
					yy797 := &x.LastTransitionTime
					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 yyq786[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy799 := &x.LastTransitionTime
					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 yyr786 || yy2arr786 {
				if yyq786[4] {
					yym802 := z.EncBinary()
					_ = yym802
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq786[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym803 := z.EncBinary()
					_ = yym803
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr786 || yy2arr786 {
				if yyq786[5] {
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq786[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym806 := z.EncBinary()
					_ = yym806
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep786 {
				r.EncodeEnd()
			}
		}
	}
}

func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym807 := z.DecBinary()
	_ = yym807
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl808 := r.ReadMapStart()
			if yyl808 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl808, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl808 := r.ReadArrayStart()
			if yyl808 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl808, 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 yys809Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys809Slc
	var yyhl809 bool = l >= 0
	for yyj809 := 0; ; yyj809++ {
		if yyhl809 {
			if yyj809 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys809Slc = r.DecodeBytes(yys809Slc, true, true)
		yys809 := string(yys809Slc)
		switch yys809 {
		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 {
				yyv812 := &x.LastProbeTime
				yym813 := z.DecBinary()
				_ = yym813
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv812) {
				} else if yym813 {
					z.DecBinaryUnmarshal(yyv812)
				} else if !yym813 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv812)
				} else {
					z.DecFallback(yyv812, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv814 := &x.LastTransitionTime
				yym815 := z.DecBinary()
				_ = yym815
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv814) {
				} else if yym815 {
					z.DecBinaryUnmarshal(yyv814)
				} else if !yym815 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv814)
				} else {
					z.DecFallback(yyv814, 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, yys809)
		} // end switch yys809
	} // end for yyj809
	if !yyhl809 {
		r.ReadEnd()
	}
}

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj818 int
	var yyb818 bool
	var yyhl818 bool = l >= 0
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv821 := &x.LastProbeTime
		yym822 := z.DecBinary()
		_ = yym822
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv821) {
		} else if yym822 {
			z.DecBinaryUnmarshal(yyv821)
		} else if !yym822 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv821)
		} else {
			z.DecFallback(yyv821, false)
		}
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv823 := &x.LastTransitionTime
		yym824 := z.DecBinary()
		_ = yym824
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv823) {
		} else if yym824 {
			z.DecBinaryUnmarshal(yyv823)
		} else if !yym824 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv823)
		} else {
			z.DecFallback(yyv823, false)
		}
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj818++
	if yyhl818 {
		yyb818 = yyj818 > l
	} else {
		yyb818 = r.CheckBreak()
	}
	if yyb818 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj818++
		if yyhl818 {
			yyb818 = yyj818 > l
		} else {
			yyb818 = r.CheckBreak()
		}
		if yyb818 {
			break
		}
		z.DecStructFieldNotFound(yyj818-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 {
		yym827 := z.EncBinary()
		_ = yym827
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep828 := !z.EncBinary()
			yy2arr828 := z.EncBasicHandle().StructToArray
			var yyq828 [5]bool
			_, _, _ = yysep828, yyq828, yy2arr828
			const yyr828 bool = false
			yyq828[0] = x.Kind != ""
			yyq828[1] = x.APIVersion != ""
			yyq828[2] = true
			yyq828[3] = true
			yyq828[4] = true
			if yyr828 || yy2arr828 {
				r.EncodeArrayStart(5)
			} else {
				var yynn828 int = 0
				for _, b := range yyq828 {
					if b {
						yynn828++
					}
				}
				r.EncodeMapStart(yynn828)
			}
			if yyr828 || yy2arr828 {
				if yyq828[0] {
					yym830 := z.EncBinary()
					_ = yym830
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq828[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym831 := z.EncBinary()
					_ = yym831
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr828 || yy2arr828 {
				if yyq828[1] {
					yym833 := z.EncBinary()
					_ = yym833
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq828[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym834 := z.EncBinary()
					_ = yym834
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr828 || yy2arr828 {
				if yyq828[2] {
					yy836 := &x.ObjectMeta
					yy836.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq828[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy837 := &x.ObjectMeta
					yy837.CodecEncodeSelf(e)
				}
			}
			if yyr828 || yy2arr828 {
				if yyq828[3] {
					yy839 := &x.Spec
					yy839.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq828[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy840 := &x.Spec
					yy840.CodecEncodeSelf(e)
				}
			}
			if yyr828 || yy2arr828 {
				if yyq828[4] {
					yy842 := &x.Status
					yy842.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq828[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy843 := &x.Status
					yy843.CodecEncodeSelf(e)
				}
			}
			if yysep828 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj852 int
	var yyb852 bool
	var yyhl852 bool = l >= 0
	yyj852++
	if yyhl852 {
		yyb852 = yyj852 > l
	} else {
		yyb852 = r.CheckBreak()
	}
	if yyb852 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj852++
	if yyhl852 {
		yyb852 = yyj852 > l
	} else {
		yyb852 = r.CheckBreak()
	}
	if yyb852 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj852++
	if yyhl852 {
		yyb852 = yyj852 > l
	} else {
		yyb852 = r.CheckBreak()
	}
	if yyb852 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv855 := &x.ObjectMeta
		yyv855.CodecDecodeSelf(d)
	}
	yyj852++
	if yyhl852 {
		yyb852 = yyj852 > l
	} else {
		yyb852 = r.CheckBreak()
	}
	if yyb852 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv856 := &x.Spec
		yyv856.CodecDecodeSelf(d)
	}
	yyj852++
	if yyhl852 {
		yyb852 = yyj852 > l
	} else {
		yyb852 = r.CheckBreak()
	}
	if yyb852 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv857 := &x.Status
		yyv857.CodecDecodeSelf(d)
	}
	for {
		yyj852++
		if yyhl852 {
			yyb852 = yyj852 > l
		} else {
			yyb852 = r.CheckBreak()
		}
		if yyb852 {
			break
		}
		z.DecStructFieldNotFound(yyj852-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 {
		yym858 := z.EncBinary()
		_ = yym858
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep859 := !z.EncBinary()
			yy2arr859 := z.EncBasicHandle().StructToArray
			var yyq859 [4]bool
			_, _, _ = yysep859, yyq859, yy2arr859
			const yyr859 bool = false
			yyq859[0] = x.Kind != ""
			yyq859[1] = x.APIVersion != ""
			yyq859[2] = true
			if yyr859 || yy2arr859 {
				r.EncodeArrayStart(4)
			} else {
				var yynn859 int = 1
				for _, b := range yyq859 {
					if b {
						yynn859++
					}
				}
				r.EncodeMapStart(yynn859)
			}
			if yyr859 || yy2arr859 {
				if yyq859[0] {
					yym861 := z.EncBinary()
					_ = yym861
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq859[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym862 := z.EncBinary()
					_ = yym862
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr859 || yy2arr859 {
				if yyq859[1] {
					yym864 := z.EncBinary()
					_ = yym864
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq859[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym865 := z.EncBinary()
					_ = yym865
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr859 || yy2arr859 {
				if yyq859[2] {
					yy867 := &x.ListMeta
					yym868 := z.EncBinary()
					_ = yym868
					if false {
					} else if z.HasExtensions() && z.EncExt(yy867) {
					} else {
						z.EncFallback(yy867)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq859[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy869 := &x.ListMeta
					yym870 := z.EncBinary()
					_ = yym870
					if false {
					} else if z.HasExtensions() && z.EncExt(yy869) {
					} else {
						z.EncFallback(yy869)
					}
				}
			}
			if yyr859 || yy2arr859 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym872 := z.EncBinary()
					_ = yym872
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym873 := z.EncBinary()
					_ = yym873
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep859 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj883 int
	var yyb883 bool
	var yyhl883 bool = l >= 0
	yyj883++
	if yyhl883 {
		yyb883 = yyj883 > l
	} else {
		yyb883 = r.CheckBreak()
	}
	if yyb883 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj883++
	if yyhl883 {
		yyb883 = yyj883 > l
	} else {
		yyb883 = r.CheckBreak()
	}
	if yyb883 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj883++
	if yyhl883 {
		yyb883 = yyj883 > l
	} else {
		yyb883 = r.CheckBreak()
	}
	if yyb883 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv886 := &x.ListMeta
		yym887 := z.DecBinary()
		_ = yym887
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv886) {
		} else {
			z.DecFallback(yyv886, false)
		}
	}
	yyj883++
	if yyhl883 {
		yyb883 = yyj883 > l
	} else {
		yyb883 = r.CheckBreak()
	}
	if yyb883 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv888 := &x.Items
		yym889 := z.DecBinary()
		_ = yym889
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv888), d)
		}
	}
	for {
		yyj883++
		if yyhl883 {
			yyb883 = yyj883 > l
		} else {
			yyb883 = r.CheckBreak()
		}
		if yyb883 {
			break
		}
		z.DecStructFieldNotFound(yyj883-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 {
		yym890 := z.EncBinary()
		_ = yym890
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep891 := !z.EncBinary()
			yy2arr891 := z.EncBasicHandle().StructToArray
			var yyq891 [2]bool
			_, _, _ = yysep891, yyq891, yy2arr891
			const yyr891 bool = false
			yyq891[0] = x.Backend != nil
			yyq891[1] = len(x.Rules) != 0
			if yyr891 || yy2arr891 {
				r.EncodeArrayStart(2)
			} else {
				var yynn891 int = 0
				for _, b := range yyq891 {
					if b {
						yynn891++
					}
				}
				r.EncodeMapStart(yynn891)
			}
			if yyr891 || yy2arr891 {
				if yyq891[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq891[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr891 || yy2arr891 {
				if yyq891[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym894 := z.EncBinary()
						_ = yym894
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq891[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym895 := z.EncBinary()
						_ = yym895
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep891 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj902 int
	var yyb902 bool
	var yyhl902 bool = l >= 0
	yyj902++
	if yyhl902 {
		yyb902 = yyj902 > l
	} else {
		yyb902 = r.CheckBreak()
	}
	if yyb902 {
		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)
	}
	yyj902++
	if yyhl902 {
		yyb902 = yyj902 > l
	} else {
		yyb902 = r.CheckBreak()
	}
	if yyb902 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv904 := &x.Rules
		yym905 := z.DecBinary()
		_ = yym905
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv904), d)
		}
	}
	for {
		yyj902++
		if yyhl902 {
			yyb902 = yyj902 > l
		} else {
			yyb902 = r.CheckBreak()
		}
		if yyb902 {
			break
		}
		z.DecStructFieldNotFound(yyj902-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 {
		yym906 := z.EncBinary()
		_ = yym906
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep907 := !z.EncBinary()
			yy2arr907 := z.EncBasicHandle().StructToArray
			var yyq907 [1]bool
			_, _, _ = yysep907, yyq907, yy2arr907
			const yyr907 bool = false
			yyq907[0] = true
			if yyr907 || yy2arr907 {
				r.EncodeArrayStart(1)
			} else {
				var yynn907 int = 0
				for _, b := range yyq907 {
					if b {
						yynn907++
					}
				}
				r.EncodeMapStart(yynn907)
			}
			if yyr907 || yy2arr907 {
				if yyq907[0] {
					yy909 := &x.LoadBalancer
					yy909.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq907[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy910 := &x.LoadBalancer
					yy910.CodecEncodeSelf(e)
				}
			}
			if yysep907 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj915 int
	var yyb915 bool
	var yyhl915 bool = l >= 0
	yyj915++
	if yyhl915 {
		yyb915 = yyj915 > l
	} else {
		yyb915 = r.CheckBreak()
	}
	if yyb915 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv916 := &x.LoadBalancer
		yyv916.CodecDecodeSelf(d)
	}
	for {
		yyj915++
		if yyhl915 {
			yyb915 = yyj915 > l
		} else {
			yyb915 = r.CheckBreak()
		}
		if yyb915 {
			break
		}
		z.DecStructFieldNotFound(yyj915-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 {
		yym917 := z.EncBinary()
		_ = yym917
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep918 := !z.EncBinary()
			yy2arr918 := z.EncBasicHandle().StructToArray
			var yyq918 [2]bool
			_, _, _ = yysep918, yyq918, yy2arr918
			const yyr918 bool = false
			yyq918[0] = x.Host != ""
			yyq918[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr918 || yy2arr918 {
				r.EncodeArrayStart(2)
			} else {
				var yynn918 int = 0
				for _, b := range yyq918 {
					if b {
						yynn918++
					}
				}
				r.EncodeMapStart(yynn918)
			}
			if yyr918 || yy2arr918 {
				if yyq918[0] {
					yym920 := z.EncBinary()
					_ = yym920
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq918[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym921 := z.EncBinary()
					_ = yym921
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn922 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn922 = true
				goto LABEL922
			}
		LABEL922:
			if yyr918 || yy2arr918 {
				if yyn922 {
					r.EncodeNil()
				} else {
					if yyq918[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq918[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn922 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep918 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj938 int
	var yyb938 bool
	var yyhl938 bool = l >= 0
	yyj938++
	if yyhl938 {
		yyb938 = yyj938 > l
	} else {
		yyb938 = r.CheckBreak()
	}
	if yyb938 {
		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 {
		yyj938++
		if yyhl938 {
			yyb938 = yyj938 > l
		} else {
			yyb938 = r.CheckBreak()
		}
		if yyb938 {
			break
		}
		z.DecStructFieldNotFound(yyj938-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 {
		yym940 := z.EncBinary()
		_ = yym940
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep941 := !z.EncBinary()
			yy2arr941 := z.EncBasicHandle().StructToArray
			var yyq941 [1]bool
			_, _, _ = yysep941, yyq941, yy2arr941
			const yyr941 bool = false
			if yyr941 || yy2arr941 {
				r.EncodeArrayStart(1)
			} else {
				var yynn941 int = 1
				for _, b := range yyq941 {
					if b {
						yynn941++
					}
				}
				r.EncodeMapStart(yynn941)
			}
			if yyr941 || yy2arr941 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym943 := z.EncBinary()
					_ = yym943
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym944 := z.EncBinary()
					_ = yym944
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep941 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj950 int
	var yyb950 bool
	var yyhl950 bool = l >= 0
	yyj950++
	if yyhl950 {
		yyb950 = yyj950 > l
	} else {
		yyb950 = r.CheckBreak()
	}
	if yyb950 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv951 := &x.Paths
		yym952 := z.DecBinary()
		_ = yym952
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv951), d)
		}
	}
	for {
		yyj950++
		if yyhl950 {
			yyb950 = yyj950 > l
		} else {
			yyb950 = r.CheckBreak()
		}
		if yyb950 {
			break
		}
		z.DecStructFieldNotFound(yyj950-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 {
		yym953 := z.EncBinary()
		_ = yym953
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep954 := !z.EncBinary()
			yy2arr954 := z.EncBasicHandle().StructToArray
			var yyq954 [2]bool
			_, _, _ = yysep954, yyq954, yy2arr954
			const yyr954 bool = false
			yyq954[0] = x.Path != ""
			if yyr954 || yy2arr954 {
				r.EncodeArrayStart(2)
			} else {
				var yynn954 int = 1
				for _, b := range yyq954 {
					if b {
						yynn954++
					}
				}
				r.EncodeMapStart(yynn954)
			}
			if yyr954 || yy2arr954 {
				if yyq954[0] {
					yym956 := z.EncBinary()
					_ = yym956
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq954[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym957 := z.EncBinary()
					_ = yym957
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr954 || yy2arr954 {
				yy959 := &x.Backend
				yy959.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy960 := &x.Backend
				yy960.CodecEncodeSelf(e)
			}
			if yysep954 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj966 int
	var yyb966 bool
	var yyhl966 bool = l >= 0
	yyj966++
	if yyhl966 {
		yyb966 = yyj966 > l
	} else {
		yyb966 = r.CheckBreak()
	}
	if yyb966 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj966++
	if yyhl966 {
		yyb966 = yyj966 > l
	} else {
		yyb966 = r.CheckBreak()
	}
	if yyb966 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv968 := &x.Backend
		yyv968.CodecDecodeSelf(d)
	}
	for {
		yyj966++
		if yyhl966 {
			yyb966 = yyj966 > l
		} else {
			yyb966 = r.CheckBreak()
		}
		if yyb966 {
			break
		}
		z.DecStructFieldNotFound(yyj966-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 {
		yym969 := z.EncBinary()
		_ = yym969
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep970 := !z.EncBinary()
			yy2arr970 := z.EncBasicHandle().StructToArray
			var yyq970 [2]bool
			_, _, _ = yysep970, yyq970, yy2arr970
			const yyr970 bool = false
			if yyr970 || yy2arr970 {
				r.EncodeArrayStart(2)
			} else {
				var yynn970 int = 2
				for _, b := range yyq970 {
					if b {
						yynn970++
					}
				}
				r.EncodeMapStart(yynn970)
			}
			if yyr970 || yy2arr970 {
				yym972 := z.EncBinary()
				_ = yym972
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym973 := z.EncBinary()
				_ = yym973
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr970 || yy2arr970 {
				yy975 := &x.ServicePort
				yym976 := z.EncBinary()
				_ = yym976
				if false {
				} else if z.HasExtensions() && z.EncExt(yy975) {
				} else if !yym976 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy975)
				} else {
					z.EncFallback(yy975)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy977 := &x.ServicePort
				yym978 := z.EncBinary()
				_ = yym978
				if false {
				} else if z.HasExtensions() && z.EncExt(yy977) {
				} else if !yym978 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy977)
				} else {
					z.EncFallback(yy977)
				}
			}
			if yysep970 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

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

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

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1023 int
	var yyb1023 bool
	var yyhl1023 bool = l >= 0
	yyj1023++
	if yyhl1023 {
		yyb1023 = yyj1023 > l
	} else {
		yyb1023 = r.CheckBreak()
	}
	if yyb1023 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1023++
	if yyhl1023 {
		yyb1023 = yyj1023 > l
	} else {
		yyb1023 = r.CheckBreak()
	}
	if yyb1023 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1023++
	if yyhl1023 {
		yyb1023 = yyj1023 > l
	} else {
		yyb1023 = r.CheckBreak()
	}
	if yyb1023 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1026 := &x.TargetUtilization
		yym1027 := z.DecBinary()
		_ = yym1027
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1026), d)
		}
	}
	for {
		yyj1023++
		if yyhl1023 {
			yyb1023 = yyj1023 > l
		} else {
			yyb1023 = r.CheckBreak()
		}
		if yyb1023 {
			break
		}
		z.DecStructFieldNotFound(yyj1023-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 {
		yym1028 := z.EncBinary()
		_ = yym1028
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1029 := !z.EncBinary()
			yy2arr1029 := z.EncBasicHandle().StructToArray
			var yyq1029 [4]bool
			_, _, _ = yysep1029, yyq1029, yy2arr1029
			const yyr1029 bool = false
			yyq1029[0] = x.Kind != ""
			yyq1029[1] = x.APIVersion != ""
			yyq1029[2] = true
			yyq1029[3] = true
			if yyr1029 || yy2arr1029 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1029 int = 0
				for _, b := range yyq1029 {
					if b {
						yynn1029++
					}
				}
				r.EncodeMapStart(yynn1029)
			}
			if yyr1029 || yy2arr1029 {
				if yyq1029[0] {
					yym1031 := z.EncBinary()
					_ = yym1031
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1029[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1032 := z.EncBinary()
					_ = yym1032
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1029 || yy2arr1029 {
				if yyq1029[1] {
					yym1034 := z.EncBinary()
					_ = yym1034
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1029[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1035 := z.EncBinary()
					_ = yym1035
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1029 || yy2arr1029 {
				if yyq1029[2] {
					yy1037 := &x.ObjectMeta
					yy1037.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1029[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1038 := &x.ObjectMeta
					yy1038.CodecEncodeSelf(e)
				}
			}
			if yyr1029 || yy2arr1029 {
				if yyq1029[3] {
					yy1040 := &x.Spec
					yy1040.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1029[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1041 := &x.Spec
					yy1041.CodecEncodeSelf(e)
				}
			}
			if yysep1029 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1049 int
	var yyb1049 bool
	var yyhl1049 bool = l >= 0
	yyj1049++
	if yyhl1049 {
		yyb1049 = yyj1049 > l
	} else {
		yyb1049 = r.CheckBreak()
	}
	if yyb1049 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1049++
	if yyhl1049 {
		yyb1049 = yyj1049 > l
	} else {
		yyb1049 = r.CheckBreak()
	}
	if yyb1049 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1049++
	if yyhl1049 {
		yyb1049 = yyj1049 > l
	} else {
		yyb1049 = r.CheckBreak()
	}
	if yyb1049 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1052 := &x.ObjectMeta
		yyv1052.CodecDecodeSelf(d)
	}
	yyj1049++
	if yyhl1049 {
		yyb1049 = yyj1049 > l
	} else {
		yyb1049 = r.CheckBreak()
	}
	if yyb1049 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1053 := &x.Spec
		yyv1053.CodecDecodeSelf(d)
	}
	for {
		yyj1049++
		if yyhl1049 {
			yyb1049 = yyj1049 > l
		} else {
			yyb1049 = r.CheckBreak()
		}
		if yyb1049 {
			break
		}
		z.DecStructFieldNotFound(yyj1049-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 {
		yym1054 := z.EncBinary()
		_ = yym1054
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1055 := !z.EncBinary()
			yy2arr1055 := z.EncBasicHandle().StructToArray
			var yyq1055 [4]bool
			_, _, _ = yysep1055, yyq1055, yy2arr1055
			const yyr1055 bool = false
			yyq1055[0] = x.Kind != ""
			yyq1055[1] = x.APIVersion != ""
			yyq1055[2] = true
			if yyr1055 || yy2arr1055 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1055 int = 1
				for _, b := range yyq1055 {
					if b {
						yynn1055++
					}
				}
				r.EncodeMapStart(yynn1055)
			}
			if yyr1055 || yy2arr1055 {
				if yyq1055[0] {
					yym1057 := z.EncBinary()
					_ = yym1057
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1055[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1058 := z.EncBinary()
					_ = yym1058
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1055 || yy2arr1055 {
				if yyq1055[1] {
					yym1060 := z.EncBinary()
					_ = yym1060
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1055[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1061 := z.EncBinary()
					_ = yym1061
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1055 || yy2arr1055 {
				if yyq1055[2] {
					yy1063 := &x.ListMeta
					yym1064 := z.EncBinary()
					_ = yym1064
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1063) {
					} else {
						z.EncFallback(yy1063)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1055[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1065 := &x.ListMeta
					yym1066 := z.EncBinary()
					_ = yym1066
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1065) {
					} else {
						z.EncFallback(yy1065)
					}
				}
			}
			if yyr1055 || yy2arr1055 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1068 := z.EncBinary()
					_ = yym1068
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1069 := z.EncBinary()
					_ = yym1069
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1055 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1079 int
	var yyb1079 bool
	var yyhl1079 bool = l >= 0
	yyj1079++
	if yyhl1079 {
		yyb1079 = yyj1079 > l
	} else {
		yyb1079 = r.CheckBreak()
	}
	if yyb1079 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1079++
	if yyhl1079 {
		yyb1079 = yyj1079 > l
	} else {
		yyb1079 = r.CheckBreak()
	}
	if yyb1079 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1079++
	if yyhl1079 {
		yyb1079 = yyj1079 > l
	} else {
		yyb1079 = r.CheckBreak()
	}
	if yyb1079 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1082 := &x.ListMeta
		yym1083 := z.DecBinary()
		_ = yym1083
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1082) {
		} else {
			z.DecFallback(yyv1082, false)
		}
	}
	yyj1079++
	if yyhl1079 {
		yyb1079 = yyj1079 > l
	} else {
		yyb1079 = r.CheckBreak()
	}
	if yyb1079 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1084 := &x.Items
		yym1085 := z.DecBinary()
		_ = yym1085
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1084), d)
		}
	}
	for {
		yyj1079++
		if yyhl1079 {
			yyb1079 = yyj1079 > l
		} else {
			yyb1079 = r.CheckBreak()
		}
		if yyb1079 {
			break
		}
		z.DecStructFieldNotFound(yyj1079-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 {
		yym1086 := z.EncBinary()
		_ = yym1086
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1087 := !z.EncBinary()
			yy2arr1087 := z.EncBasicHandle().StructToArray
			var yyq1087 [2]bool
			_, _, _ = yysep1087, yyq1087, yy2arr1087
			const yyr1087 bool = false
			yyq1087[0] = len(x.MatchLabels) != 0
			yyq1087[1] = len(x.MatchExpressions) != 0
			if yyr1087 || yy2arr1087 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1087 int = 0
				for _, b := range yyq1087 {
					if b {
						yynn1087++
					}
				}
				r.EncodeMapStart(yynn1087)
			}
			if yyr1087 || yy2arr1087 {
				if yyq1087[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1089 := z.EncBinary()
						_ = yym1089
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1087[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1090 := z.EncBinary()
						_ = yym1090
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1087 || yy2arr1087 {
				if yyq1087[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1092 := z.EncBinary()
						_ = yym1092
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1087[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1093 := z.EncBinary()
						_ = yym1093
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1087 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1101 int
	var yyb1101 bool
	var yyhl1101 bool = l >= 0
	yyj1101++
	if yyhl1101 {
		yyb1101 = yyj1101 > l
	} else {
		yyb1101 = r.CheckBreak()
	}
	if yyb1101 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1102 := &x.MatchLabels
		yym1103 := z.DecBinary()
		_ = yym1103
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1102, false, d)
		}
	}
	yyj1101++
	if yyhl1101 {
		yyb1101 = yyj1101 > l
	} else {
		yyb1101 = r.CheckBreak()
	}
	if yyb1101 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1104 := &x.MatchExpressions
		yym1105 := z.DecBinary()
		_ = yym1105
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1104), d)
		}
	}
	for {
		yyj1101++
		if yyhl1101 {
			yyb1101 = yyj1101 > l
		} else {
			yyb1101 = r.CheckBreak()
		}
		if yyb1101 {
			break
		}
		z.DecStructFieldNotFound(yyj1101-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 {
		yym1106 := z.EncBinary()
		_ = yym1106
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1107 := !z.EncBinary()
			yy2arr1107 := z.EncBasicHandle().StructToArray
			var yyq1107 [3]bool
			_, _, _ = yysep1107, yyq1107, yy2arr1107
			const yyr1107 bool = false
			yyq1107[2] = len(x.Values) != 0
			if yyr1107 || yy2arr1107 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1107 int = 2
				for _, b := range yyq1107 {
					if b {
						yynn1107++
					}
				}
				r.EncodeMapStart(yynn1107)
			}
			if yyr1107 || yy2arr1107 {
				yym1109 := z.EncBinary()
				_ = yym1109
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1110 := z.EncBinary()
				_ = yym1110
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1107 || yy2arr1107 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1107 || yy2arr1107 {
				if yyq1107[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1113 := z.EncBinary()
						_ = yym1113
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1107[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1114 := z.EncBinary()
						_ = yym1114
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1107 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

	yyv1131 := *v
	yyh1131, yyl1131 := z.DecSliceHelperStart()

	var yyrr1131, yyrl1131 int
	var yyc1131, yyrt1131 bool
	_, _, _ = yyc1131, yyrt1131, yyrl1131
	yyrr1131 = yyl1131

	if yyv1131 == nil {
		if yyrl1131, yyrt1131 = z.DecInferLen(yyl1131, z.DecBasicHandle().MaxInitLen, 320); yyrt1131 {
			yyrr1131 = yyrl1131
		}
		yyv1131 = make([]HorizontalPodAutoscaler, yyrl1131)
		yyc1131 = true
	}

	if yyl1131 == 0 {
		if len(yyv1131) != 0 {
			yyv1131 = yyv1131[:0]
			yyc1131 = true
		}
	} else if yyl1131 > 0 {

		if yyl1131 > cap(yyv1131) {
			yyrl1131, yyrt1131 = z.DecInferLen(yyl1131, z.DecBasicHandle().MaxInitLen, 320)
			yyv1131 = make([]HorizontalPodAutoscaler, yyrl1131)
			yyc1131 = true

			yyrr1131 = len(yyv1131)
		} else if yyl1131 != len(yyv1131) {
			yyv1131 = yyv1131[:yyl1131]
			yyc1131 = true
		}
		yyj1131 := 0
		for ; yyj1131 < yyrr1131; yyj1131++ {
			if r.TryDecodeAsNil() {
				yyv1131[yyj1131] = HorizontalPodAutoscaler{}
			} else {
				yyv1132 := &yyv1131[yyj1131]
				yyv1132.CodecDecodeSelf(d)
			}

		}
		if yyrt1131 {
			for ; yyj1131 < yyl1131; yyj1131++ {
				yyv1131 = append(yyv1131, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1131[yyj1131] = HorizontalPodAutoscaler{}
				} else {
					yyv1133 := &yyv1131[yyj1131]
					yyv1133.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1131 := 0; !r.CheckBreak(); yyj1131++ {
			if yyj1131 >= len(yyv1131) {
				yyv1131 = append(yyv1131, HorizontalPodAutoscaler{}) // var yyz1131 HorizontalPodAutoscaler
				yyc1131 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1131.End()
	}
	if yyc1131 {
		*v = yyv1131
	}

}

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

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

	yyv1137 := *v
	yyh1137, yyl1137 := z.DecSliceHelperStart()

	var yyrr1137, yyrl1137 int
	var yyc1137, yyrt1137 bool
	_, _, _ = yyc1137, yyrt1137, yyrl1137
	yyrr1137 = yyl1137

	if yyv1137 == nil {
		if yyrl1137, yyrt1137 = z.DecInferLen(yyl1137, z.DecBasicHandle().MaxInitLen, 32); yyrt1137 {
			yyrr1137 = yyrl1137
		}
		yyv1137 = make([]APIVersion, yyrl1137)
		yyc1137 = true
	}

	if yyl1137 == 0 {
		if len(yyv1137) != 0 {
			yyv1137 = yyv1137[:0]
			yyc1137 = true
		}
	} else if yyl1137 > 0 {

		if yyl1137 > cap(yyv1137) {
			yyrl1137, yyrt1137 = z.DecInferLen(yyl1137, z.DecBasicHandle().MaxInitLen, 32)
			yyv1137 = make([]APIVersion, yyrl1137)
			yyc1137 = true

			yyrr1137 = len(yyv1137)
		} else if yyl1137 != len(yyv1137) {
			yyv1137 = yyv1137[:yyl1137]
			yyc1137 = true
		}
		yyj1137 := 0
		for ; yyj1137 < yyrr1137; yyj1137++ {
			if r.TryDecodeAsNil() {
				yyv1137[yyj1137] = APIVersion{}
			} else {
				yyv1138 := &yyv1137[yyj1137]
				yyv1138.CodecDecodeSelf(d)
			}

		}
		if yyrt1137 {
			for ; yyj1137 < yyl1137; yyj1137++ {
				yyv1137 = append(yyv1137, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1137[yyj1137] = APIVersion{}
				} else {
					yyv1139 := &yyv1137[yyj1137]
					yyv1139.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1137 := 0; !r.CheckBreak(); yyj1137++ {
			if yyj1137 >= len(yyv1137) {
				yyv1137 = append(yyv1137, APIVersion{}) // var yyz1137 APIVersion
				yyc1137 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1137.End()
	}
	if yyc1137 {
		*v = yyv1137
	}

}

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

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

	yyv1143 := *v
	yyh1143, yyl1143 := z.DecSliceHelperStart()

	var yyrr1143, yyrl1143 int
	var yyc1143, yyrt1143 bool
	_, _, _ = yyc1143, yyrt1143, yyrl1143
	yyrr1143 = yyl1143

	if yyv1143 == nil {
		if yyrl1143, yyrt1143 = z.DecInferLen(yyl1143, z.DecBasicHandle().MaxInitLen, 232); yyrt1143 {
			yyrr1143 = yyrl1143
		}
		yyv1143 = make([]ThirdPartyResource, yyrl1143)
		yyc1143 = true
	}

	if yyl1143 == 0 {
		if len(yyv1143) != 0 {
			yyv1143 = yyv1143[:0]
			yyc1143 = true
		}
	} else if yyl1143 > 0 {

		if yyl1143 > cap(yyv1143) {
			yyrl1143, yyrt1143 = z.DecInferLen(yyl1143, z.DecBasicHandle().MaxInitLen, 232)
			yyv1143 = make([]ThirdPartyResource, yyrl1143)
			yyc1143 = true

			yyrr1143 = len(yyv1143)
		} else if yyl1143 != len(yyv1143) {
			yyv1143 = yyv1143[:yyl1143]
			yyc1143 = true
		}
		yyj1143 := 0
		for ; yyj1143 < yyrr1143; yyj1143++ {
			if r.TryDecodeAsNil() {
				yyv1143[yyj1143] = ThirdPartyResource{}
			} else {
				yyv1144 := &yyv1143[yyj1143]
				yyv1144.CodecDecodeSelf(d)
			}

		}
		if yyrt1143 {
			for ; yyj1143 < yyl1143; yyj1143++ {
				yyv1143 = append(yyv1143, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1143[yyj1143] = ThirdPartyResource{}
				} else {
					yyv1145 := &yyv1143[yyj1143]
					yyv1145.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1143 := 0; !r.CheckBreak(); yyj1143++ {
			if yyj1143 >= len(yyv1143) {
				yyv1143 = append(yyv1143, ThirdPartyResource{}) // var yyz1143 ThirdPartyResource
				yyc1143 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1143.End()
	}
	if yyc1143 {
		*v = yyv1143
	}

}

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

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

	yyv1149 := *v
	yyh1149, yyl1149 := z.DecSliceHelperStart()

	var yyrr1149, yyrl1149 int
	var yyc1149, yyrt1149 bool
	_, _, _ = yyc1149, yyrt1149, yyrl1149
	yyrr1149 = yyl1149

	if yyv1149 == nil {
		if yyrl1149, yyrt1149 = z.DecInferLen(yyl1149, z.DecBasicHandle().MaxInitLen, 608); yyrt1149 {
			yyrr1149 = yyrl1149
		}
		yyv1149 = make([]Deployment, yyrl1149)
		yyc1149 = true
	}

	if yyl1149 == 0 {
		if len(yyv1149) != 0 {
			yyv1149 = yyv1149[:0]
			yyc1149 = true
		}
	} else if yyl1149 > 0 {

		if yyl1149 > cap(yyv1149) {
			yyrl1149, yyrt1149 = z.DecInferLen(yyl1149, z.DecBasicHandle().MaxInitLen, 608)
			yyv1149 = make([]Deployment, yyrl1149)
			yyc1149 = true

			yyrr1149 = len(yyv1149)
		} else if yyl1149 != len(yyv1149) {
			yyv1149 = yyv1149[:yyl1149]
			yyc1149 = true
		}
		yyj1149 := 0
		for ; yyj1149 < yyrr1149; yyj1149++ {
			if r.TryDecodeAsNil() {
				yyv1149[yyj1149] = Deployment{}
			} else {
				yyv1150 := &yyv1149[yyj1149]
				yyv1150.CodecDecodeSelf(d)
			}

		}
		if yyrt1149 {
			for ; yyj1149 < yyl1149; yyj1149++ {
				yyv1149 = append(yyv1149, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1149[yyj1149] = Deployment{}
				} else {
					yyv1151 := &yyv1149[yyj1149]
					yyv1151.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1149 := 0; !r.CheckBreak(); yyj1149++ {
			if yyj1149 >= len(yyv1149) {
				yyv1149 = append(yyv1149, Deployment{}) // var yyz1149 Deployment
				yyc1149 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1149.End()
	}
	if yyc1149 {
		*v = yyv1149
	}

}

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

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

	yyv1155 := *v
	yyh1155, yyl1155 := z.DecSliceHelperStart()

	var yyrr1155, yyrl1155 int
	var yyc1155, yyrt1155 bool
	_, _, _ = yyc1155, yyrt1155, yyrl1155
	yyrr1155 = yyl1155

	if yyv1155 == nil {
		if yyrl1155, yyrt1155 = z.DecInferLen(yyl1155, z.DecBasicHandle().MaxInitLen, 232); yyrt1155 {
			yyrr1155 = yyrl1155
		}
		yyv1155 = make([]DaemonSet, yyrl1155)
		yyc1155 = true
	}

	if yyl1155 == 0 {
		if len(yyv1155) != 0 {
			yyv1155 = yyv1155[:0]
			yyc1155 = true
		}
	} else if yyl1155 > 0 {

		if yyl1155 > cap(yyv1155) {
			yyrl1155, yyrt1155 = z.DecInferLen(yyl1155, z.DecBasicHandle().MaxInitLen, 232)
			yyv1155 = make([]DaemonSet, yyrl1155)
			yyc1155 = true

			yyrr1155 = len(yyv1155)
		} else if yyl1155 != len(yyv1155) {
			yyv1155 = yyv1155[:yyl1155]
			yyc1155 = true
		}
		yyj1155 := 0
		for ; yyj1155 < yyrr1155; yyj1155++ {
			if r.TryDecodeAsNil() {
				yyv1155[yyj1155] = DaemonSet{}
			} else {
				yyv1156 := &yyv1155[yyj1155]
				yyv1156.CodecDecodeSelf(d)
			}

		}
		if yyrt1155 {
			for ; yyj1155 < yyl1155; yyj1155++ {
				yyv1155 = append(yyv1155, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1155[yyj1155] = DaemonSet{}
				} else {
					yyv1157 := &yyv1155[yyj1155]
					yyv1157.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1155 := 0; !r.CheckBreak(); yyj1155++ {
			if yyj1155 >= len(yyv1155) {
				yyv1155 = append(yyv1155, DaemonSet{}) // var yyz1155 DaemonSet
				yyc1155 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1155.End()
	}
	if yyc1155 {
		*v = yyv1155
	}

}

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

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

	yyv1161 := *v
	yyh1161, yyl1161 := z.DecSliceHelperStart()

	var yyrr1161, yyrl1161 int
	var yyc1161, yyrt1161 bool
	_, _, _ = yyc1161, yyrt1161, yyrl1161
	yyrr1161 = yyl1161

	if yyv1161 == nil {
		if yyrl1161, yyrt1161 = z.DecInferLen(yyl1161, z.DecBasicHandle().MaxInitLen, 216); yyrt1161 {
			yyrr1161 = yyrl1161
		}
		yyv1161 = make([]ThirdPartyResourceData, yyrl1161)
		yyc1161 = true
	}

	if yyl1161 == 0 {
		if len(yyv1161) != 0 {
			yyv1161 = yyv1161[:0]
			yyc1161 = true
		}
	} else if yyl1161 > 0 {

		if yyl1161 > cap(yyv1161) {
			yyrl1161, yyrt1161 = z.DecInferLen(yyl1161, z.DecBasicHandle().MaxInitLen, 216)
			yyv1161 = make([]ThirdPartyResourceData, yyrl1161)
			yyc1161 = true

			yyrr1161 = len(yyv1161)
		} else if yyl1161 != len(yyv1161) {
			yyv1161 = yyv1161[:yyl1161]
			yyc1161 = true
		}
		yyj1161 := 0
		for ; yyj1161 < yyrr1161; yyj1161++ {
			if r.TryDecodeAsNil() {
				yyv1161[yyj1161] = ThirdPartyResourceData{}
			} else {
				yyv1162 := &yyv1161[yyj1161]
				yyv1162.CodecDecodeSelf(d)
			}

		}
		if yyrt1161 {
			for ; yyj1161 < yyl1161; yyj1161++ {
				yyv1161 = append(yyv1161, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1161[yyj1161] = ThirdPartyResourceData{}
				} else {
					yyv1163 := &yyv1161[yyj1161]
					yyv1163.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1161 := 0; !r.CheckBreak(); yyj1161++ {
			if yyj1161 >= len(yyv1161) {
				yyv1161 = append(yyv1161, ThirdPartyResourceData{}) // var yyz1161 ThirdPartyResourceData
				yyc1161 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1161.End()
	}
	if yyc1161 {
		*v = yyv1161
	}

}

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

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

	yyv1167 := *v
	yyh1167, yyl1167 := z.DecSliceHelperStart()

	var yyrr1167, yyrl1167 int
	var yyc1167, yyrt1167 bool
	_, _, _ = yyc1167, yyrt1167, yyrl1167
	yyrr1167 = yyl1167

	if yyv1167 == nil {
		if yyrl1167, yyrt1167 = z.DecInferLen(yyl1167, z.DecBasicHandle().MaxInitLen, 632); yyrt1167 {
			yyrr1167 = yyrl1167
		}
		yyv1167 = make([]Job, yyrl1167)
		yyc1167 = true
	}

	if yyl1167 == 0 {
		if len(yyv1167) != 0 {
			yyv1167 = yyv1167[:0]
			yyc1167 = true
		}
	} else if yyl1167 > 0 {

		if yyl1167 > cap(yyv1167) {
			yyrl1167, yyrt1167 = z.DecInferLen(yyl1167, z.DecBasicHandle().MaxInitLen, 632)
			yyv1167 = make([]Job, yyrl1167)
			yyc1167 = true

			yyrr1167 = len(yyv1167)
		} else if yyl1167 != len(yyv1167) {
			yyv1167 = yyv1167[:yyl1167]
			yyc1167 = true
		}
		yyj1167 := 0
		for ; yyj1167 < yyrr1167; yyj1167++ {
			if r.TryDecodeAsNil() {
				yyv1167[yyj1167] = Job{}
			} else {
				yyv1168 := &yyv1167[yyj1167]
				yyv1168.CodecDecodeSelf(d)
			}

		}
		if yyrt1167 {
			for ; yyj1167 < yyl1167; yyj1167++ {
				yyv1167 = append(yyv1167, Job{})
				if r.TryDecodeAsNil() {
					yyv1167[yyj1167] = Job{}
				} else {
					yyv1169 := &yyv1167[yyj1167]
					yyv1169.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1167 := 0; !r.CheckBreak(); yyj1167++ {
			if yyj1167 >= len(yyv1167) {
				yyv1167 = append(yyv1167, Job{}) // var yyz1167 Job
				yyc1167 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1167.End()
	}
	if yyc1167 {
		*v = yyv1167
	}

}

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

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

	yyv1173 := *v
	yyh1173, yyl1173 := z.DecSliceHelperStart()

	var yyrr1173, yyrl1173 int
	var yyc1173, yyrt1173 bool
	_, _, _ = yyc1173, yyrt1173, yyrl1173
	yyrr1173 = yyl1173

	if yyv1173 == nil {
		if yyrl1173, yyrt1173 = z.DecInferLen(yyl1173, z.DecBasicHandle().MaxInitLen, 112); yyrt1173 {
			yyrr1173 = yyrl1173
		}
		yyv1173 = make([]JobCondition, yyrl1173)
		yyc1173 = true
	}

	if yyl1173 == 0 {
		if len(yyv1173) != 0 {
			yyv1173 = yyv1173[:0]
			yyc1173 = true
		}
	} else if yyl1173 > 0 {

		if yyl1173 > cap(yyv1173) {
			yyrl1173, yyrt1173 = z.DecInferLen(yyl1173, z.DecBasicHandle().MaxInitLen, 112)
			yyv1173 = make([]JobCondition, yyrl1173)
			yyc1173 = true

			yyrr1173 = len(yyv1173)
		} else if yyl1173 != len(yyv1173) {
			yyv1173 = yyv1173[:yyl1173]
			yyc1173 = true
		}
		yyj1173 := 0
		for ; yyj1173 < yyrr1173; yyj1173++ {
			if r.TryDecodeAsNil() {
				yyv1173[yyj1173] = JobCondition{}
			} else {
				yyv1174 := &yyv1173[yyj1173]
				yyv1174.CodecDecodeSelf(d)
			}

		}
		if yyrt1173 {
			for ; yyj1173 < yyl1173; yyj1173++ {
				yyv1173 = append(yyv1173, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1173[yyj1173] = JobCondition{}
				} else {
					yyv1175 := &yyv1173[yyj1173]
					yyv1175.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1173 := 0; !r.CheckBreak(); yyj1173++ {
			if yyj1173 >= len(yyv1173) {
				yyv1173 = append(yyv1173, JobCondition{}) // var yyz1173 JobCondition
				yyc1173 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1173.End()
	}
	if yyc1173 {
		*v = yyv1173
	}

}

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

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

	yyv1179 := *v
	yyh1179, yyl1179 := z.DecSliceHelperStart()

	var yyrr1179, yyrl1179 int
	var yyc1179, yyrt1179 bool
	_, _, _ = yyc1179, yyrt1179, yyrl1179
	yyrr1179 = yyl1179

	if yyv1179 == nil {
		if yyrl1179, yyrt1179 = z.DecInferLen(yyl1179, z.DecBasicHandle().MaxInitLen, 248); yyrt1179 {
			yyrr1179 = yyrl1179
		}
		yyv1179 = make([]Ingress, yyrl1179)
		yyc1179 = true
	}

	if yyl1179 == 0 {
		if len(yyv1179) != 0 {
			yyv1179 = yyv1179[:0]
			yyc1179 = true
		}
	} else if yyl1179 > 0 {

		if yyl1179 > cap(yyv1179) {
			yyrl1179, yyrt1179 = z.DecInferLen(yyl1179, z.DecBasicHandle().MaxInitLen, 248)
			yyv1179 = make([]Ingress, yyrl1179)
			yyc1179 = true

			yyrr1179 = len(yyv1179)
		} else if yyl1179 != len(yyv1179) {
			yyv1179 = yyv1179[:yyl1179]
			yyc1179 = true
		}
		yyj1179 := 0
		for ; yyj1179 < yyrr1179; yyj1179++ {
			if r.TryDecodeAsNil() {
				yyv1179[yyj1179] = Ingress{}
			} else {
				yyv1180 := &yyv1179[yyj1179]
				yyv1180.CodecDecodeSelf(d)
			}

		}
		if yyrt1179 {
			for ; yyj1179 < yyl1179; yyj1179++ {
				yyv1179 = append(yyv1179, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1179[yyj1179] = Ingress{}
				} else {
					yyv1181 := &yyv1179[yyj1179]
					yyv1181.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1179 := 0; !r.CheckBreak(); yyj1179++ {
			if yyj1179 >= len(yyv1179) {
				yyv1179 = append(yyv1179, Ingress{}) // var yyz1179 Ingress
				yyc1179 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1179.End()
	}
	if yyc1179 {
		*v = yyv1179
	}

}

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

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

	yyv1185 := *v
	yyh1185, yyl1185 := z.DecSliceHelperStart()

	var yyrr1185, yyrl1185 int
	var yyc1185, yyrt1185 bool
	_, _, _ = yyc1185, yyrt1185, yyrl1185
	yyrr1185 = yyl1185

	if yyv1185 == nil {
		if yyrl1185, yyrt1185 = z.DecInferLen(yyl1185, z.DecBasicHandle().MaxInitLen, 24); yyrt1185 {
			yyrr1185 = yyrl1185
		}
		yyv1185 = make([]IngressRule, yyrl1185)
		yyc1185 = true
	}

	if yyl1185 == 0 {
		if len(yyv1185) != 0 {
			yyv1185 = yyv1185[:0]
			yyc1185 = true
		}
	} else if yyl1185 > 0 {

		if yyl1185 > cap(yyv1185) {
			yyrl1185, yyrt1185 = z.DecInferLen(yyl1185, z.DecBasicHandle().MaxInitLen, 24)
			yyv1185 = make([]IngressRule, yyrl1185)
			yyc1185 = true

			yyrr1185 = len(yyv1185)
		} else if yyl1185 != len(yyv1185) {
			yyv1185 = yyv1185[:yyl1185]
			yyc1185 = true
		}
		yyj1185 := 0
		for ; yyj1185 < yyrr1185; yyj1185++ {
			if r.TryDecodeAsNil() {
				yyv1185[yyj1185] = IngressRule{}
			} else {
				yyv1186 := &yyv1185[yyj1185]
				yyv1186.CodecDecodeSelf(d)
			}

		}
		if yyrt1185 {
			for ; yyj1185 < yyl1185; yyj1185++ {
				yyv1185 = append(yyv1185, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1185[yyj1185] = IngressRule{}
				} else {
					yyv1187 := &yyv1185[yyj1185]
					yyv1187.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1185 := 0; !r.CheckBreak(); yyj1185++ {
			if yyj1185 >= len(yyv1185) {
				yyv1185 = append(yyv1185, IngressRule{}) // var yyz1185 IngressRule
				yyc1185 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1185.End()
	}
	if yyc1185 {
		*v = yyv1185
	}

}

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

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

	yyv1191 := *v
	yyh1191, yyl1191 := z.DecSliceHelperStart()

	var yyrr1191, yyrl1191 int
	var yyc1191, yyrt1191 bool
	_, _, _ = yyc1191, yyrt1191, yyrl1191
	yyrr1191 = yyl1191

	if yyv1191 == nil {
		if yyrl1191, yyrt1191 = z.DecInferLen(yyl1191, z.DecBasicHandle().MaxInitLen, 64); yyrt1191 {
			yyrr1191 = yyrl1191
		}
		yyv1191 = make([]HTTPIngressPath, yyrl1191)
		yyc1191 = true
	}

	if yyl1191 == 0 {
		if len(yyv1191) != 0 {
			yyv1191 = yyv1191[:0]
			yyc1191 = true
		}
	} else if yyl1191 > 0 {

		if yyl1191 > cap(yyv1191) {
			yyrl1191, yyrt1191 = z.DecInferLen(yyl1191, z.DecBasicHandle().MaxInitLen, 64)
			yyv1191 = make([]HTTPIngressPath, yyrl1191)
			yyc1191 = true

			yyrr1191 = len(yyv1191)
		} else if yyl1191 != len(yyv1191) {
			yyv1191 = yyv1191[:yyl1191]
			yyc1191 = true
		}
		yyj1191 := 0
		for ; yyj1191 < yyrr1191; yyj1191++ {
			if r.TryDecodeAsNil() {
				yyv1191[yyj1191] = HTTPIngressPath{}
			} else {
				yyv1192 := &yyv1191[yyj1191]
				yyv1192.CodecDecodeSelf(d)
			}

		}
		if yyrt1191 {
			for ; yyj1191 < yyl1191; yyj1191++ {
				yyv1191 = append(yyv1191, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1191[yyj1191] = HTTPIngressPath{}
				} else {
					yyv1193 := &yyv1191[yyj1191]
					yyv1193.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1191 := 0; !r.CheckBreak(); yyj1191++ {
			if yyj1191 >= len(yyv1191) {
				yyv1191 = append(yyv1191, HTTPIngressPath{}) // var yyz1191 HTTPIngressPath
				yyc1191 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1191.End()
	}
	if yyc1191 {
		*v = yyv1191
	}

}

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

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

	yyv1197 := *v
	yyh1197, yyl1197 := z.DecSliceHelperStart()

	var yyrr1197, yyrl1197 int
	var yyc1197, yyrt1197 bool
	_, _, _ = yyc1197, yyrt1197, yyrl1197
	yyrr1197 = yyl1197

	if yyv1197 == nil {
		if yyrl1197, yyrt1197 = z.DecInferLen(yyl1197, z.DecBasicHandle().MaxInitLen, 24); yyrt1197 {
			yyrr1197 = yyrl1197
		}
		yyv1197 = make([]NodeUtilization, yyrl1197)
		yyc1197 = true
	}

	if yyl1197 == 0 {
		if len(yyv1197) != 0 {
			yyv1197 = yyv1197[:0]
			yyc1197 = true
		}
	} else if yyl1197 > 0 {

		if yyl1197 > cap(yyv1197) {
			yyrl1197, yyrt1197 = z.DecInferLen(yyl1197, z.DecBasicHandle().MaxInitLen, 24)
			yyv1197 = make([]NodeUtilization, yyrl1197)
			yyc1197 = true

			yyrr1197 = len(yyv1197)
		} else if yyl1197 != len(yyv1197) {
			yyv1197 = yyv1197[:yyl1197]
			yyc1197 = true
		}
		yyj1197 := 0
		for ; yyj1197 < yyrr1197; yyj1197++ {
			if r.TryDecodeAsNil() {
				yyv1197[yyj1197] = NodeUtilization{}
			} else {
				yyv1198 := &yyv1197[yyj1197]
				yyv1198.CodecDecodeSelf(d)
			}

		}
		if yyrt1197 {
			for ; yyj1197 < yyl1197; yyj1197++ {
				yyv1197 = append(yyv1197, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1197[yyj1197] = NodeUtilization{}
				} else {
					yyv1199 := &yyv1197[yyj1197]
					yyv1199.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1197 := 0; !r.CheckBreak(); yyj1197++ {
			if yyj1197 >= len(yyv1197) {
				yyv1197 = append(yyv1197, NodeUtilization{}) // var yyz1197 NodeUtilization
				yyc1197 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1197.End()
	}
	if yyc1197 {
		*v = yyv1197
	}

}

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

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

	yyv1203 := *v
	yyh1203, yyl1203 := z.DecSliceHelperStart()

	var yyrr1203, yyrl1203 int
	var yyc1203, yyrt1203 bool
	_, _, _ = yyc1203, yyrt1203, yyrl1203
	yyrr1203 = yyl1203

	if yyv1203 == nil {
		if yyrl1203, yyrt1203 = z.DecInferLen(yyl1203, z.DecBasicHandle().MaxInitLen, 232); yyrt1203 {
			yyrr1203 = yyrl1203
		}
		yyv1203 = make([]ClusterAutoscaler, yyrl1203)
		yyc1203 = true
	}

	if yyl1203 == 0 {
		if len(yyv1203) != 0 {
			yyv1203 = yyv1203[:0]
			yyc1203 = true
		}
	} else if yyl1203 > 0 {

		if yyl1203 > cap(yyv1203) {
			yyrl1203, yyrt1203 = z.DecInferLen(yyl1203, z.DecBasicHandle().MaxInitLen, 232)
			yyv1203 = make([]ClusterAutoscaler, yyrl1203)
			yyc1203 = true

			yyrr1203 = len(yyv1203)
		} else if yyl1203 != len(yyv1203) {
			yyv1203 = yyv1203[:yyl1203]
			yyc1203 = true
		}
		yyj1203 := 0
		for ; yyj1203 < yyrr1203; yyj1203++ {
			if r.TryDecodeAsNil() {
				yyv1203[yyj1203] = ClusterAutoscaler{}
			} else {
				yyv1204 := &yyv1203[yyj1203]
				yyv1204.CodecDecodeSelf(d)
			}

		}
		if yyrt1203 {
			for ; yyj1203 < yyl1203; yyj1203++ {
				yyv1203 = append(yyv1203, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1203[yyj1203] = ClusterAutoscaler{}
				} else {
					yyv1205 := &yyv1203[yyj1203]
					yyv1205.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1203 := 0; !r.CheckBreak(); yyj1203++ {
			if yyj1203 >= len(yyv1203) {
				yyv1203 = append(yyv1203, ClusterAutoscaler{}) // var yyz1203 ClusterAutoscaler
				yyc1203 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1203.End()
	}
	if yyc1203 {
		*v = yyv1203
	}

}

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

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

	yyv1209 := *v
	yyh1209, yyl1209 := z.DecSliceHelperStart()

	var yyrr1209, yyrl1209 int
	var yyc1209, yyrt1209 bool
	_, _, _ = yyc1209, yyrt1209, yyrl1209
	yyrr1209 = yyl1209

	if yyv1209 == nil {
		if yyrl1209, yyrt1209 = z.DecInferLen(yyl1209, z.DecBasicHandle().MaxInitLen, 56); yyrt1209 {
			yyrr1209 = yyrl1209
		}
		yyv1209 = make([]PodSelectorRequirement, yyrl1209)
		yyc1209 = true
	}

	if yyl1209 == 0 {
		if len(yyv1209) != 0 {
			yyv1209 = yyv1209[:0]
			yyc1209 = true
		}
	} else if yyl1209 > 0 {

		if yyl1209 > cap(yyv1209) {
			yyrl1209, yyrt1209 = z.DecInferLen(yyl1209, z.DecBasicHandle().MaxInitLen, 56)
			yyv1209 = make([]PodSelectorRequirement, yyrl1209)
			yyc1209 = true

			yyrr1209 = len(yyv1209)
		} else if yyl1209 != len(yyv1209) {
			yyv1209 = yyv1209[:yyl1209]
			yyc1209 = true
		}
		yyj1209 := 0
		for ; yyj1209 < yyrr1209; yyj1209++ {
			if r.TryDecodeAsNil() {
				yyv1209[yyj1209] = PodSelectorRequirement{}
			} else {
				yyv1210 := &yyv1209[yyj1209]
				yyv1210.CodecDecodeSelf(d)
			}

		}
		if yyrt1209 {
			for ; yyj1209 < yyl1209; yyj1209++ {
				yyv1209 = append(yyv1209, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1209[yyj1209] = PodSelectorRequirement{}
				} else {
					yyv1211 := &yyv1209[yyj1209]
					yyv1211.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1209 := 0; !r.CheckBreak(); yyj1209++ {
			if yyj1209 >= len(yyv1209) {
				yyv1209 = append(yyv1209, PodSelectorRequirement{}) // var yyz1209 PodSelectorRequirement
				yyc1209 = true
			}

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

			} else {
				z.DecSwallow()
			}

		}
		yyh1209.End()
	}
	if yyc1209 {
		*v = yyv1209
	}

}
