/*
Copyright 2015 The Kubernetes Authors All rights reserved.

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

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

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

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

package extensions

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

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

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

type codecSelfer1234 struct{}

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

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

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

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

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

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

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

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

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

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

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

func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys49Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys49Slc
	var yyhl49 bool = l >= 0
	for yyj49 := 0; ; yyj49++ {
		if yyhl49 {
			if yyj49 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys49Slc = r.DecodeBytes(yys49Slc, true, true)
		yys49 := string(yys49Slc)
		switch yys49 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	if !yyhl49 {
		r.ReadEnd()
	}
}

func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj55 int
	var yyb55 bool
	var yyhl55 bool = l >= 0
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv58 := &x.ObjectMeta
		yyv58.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv59 := &x.Spec
		yyv59.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv60 := &x.Status
		yyv60.CodecDecodeSelf(d)
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecStructFieldNotFound(yyj55-1, "")
	}
	r.ReadEnd()
}

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

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

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

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

func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym77 := z.EncBinary()
		_ = yym77
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep78 := !z.EncBinary()
			yy2arr78 := z.EncBasicHandle().StructToArray
			var yyq78 [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_api.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_api.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_api.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_api.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_api.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_api.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_api.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_api.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 != 0
			yyq387[1] = len(x.Selector) != 0
			yyq387[3] = true
			yyq387[4] = x.UniqueLabelKey != ""
			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] {
					yym389 := z.EncBinary()
					_ = yym389
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq387[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym390 := z.EncBinary()
					_ = yym390
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr387 || yy2arr387 {
				if yyq387[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym392 := z.EncBinary()
						_ = yym392
						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 {
						yym393 := z.EncBinary()
						_ = yym393
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr387 || yy2arr387 {
				yy395 := &x.Template
				yy395.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy396 := &x.Template
				yy396.CodecEncodeSelf(e)
			}
			if yyr387 || yy2arr387 {
				if yyq387[3] {
					yy398 := &x.Strategy
					yy398.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[3] {
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					yy399 := &x.Strategy
					yy399.CodecEncodeSelf(e)
				}
			}
			if yyr387 || yy2arr387 {
				if yyq387[4] {
					yym401 := z.EncBinary()
					_ = yym401
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq387[4] {
					r.EncodeString(codecSelferC_UTF81234, string("uniqueLabelKey"))
					yym402 := z.EncBinary()
					_ = yym402
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.UniqueLabelKey))
					}
				}
			}
			if yysep387 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj412 int
	var yyb412 bool
	var yyhl412 bool = l >= 0
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv414 := &x.Selector
		yym415 := z.DecBinary()
		_ = yym415
		if false {
		} else {
			z.F.DecMapStringStringX(yyv414, false, d)
		}
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv416 := &x.Template
		yyv416.CodecDecodeSelf(d)
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv417 := &x.Strategy
		yyv417.CodecDecodeSelf(d)
	}
	yyj412++
	if yyhl412 {
		yyb412 = yyj412 > l
	} else {
		yyb412 = r.CheckBreak()
	}
	if yyb412 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UniqueLabelKey = ""
	} else {
		x.UniqueLabelKey = string(r.DecodeString())
	}
	for {
		yyj412++
		if yyhl412 {
			yyb412 = yyj412 > l
		} else {
			yyb412 = r.CheckBreak()
		}
		if yyb412 {
			break
		}
		z.DecStructFieldNotFound(yyj412-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 {
		yym419 := z.EncBinary()
		_ = yym419
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep420 := !z.EncBinary()
			yy2arr420 := z.EncBasicHandle().StructToArray
			var yyq420 [2]bool
			_, _, _ = yysep420, yyq420, yy2arr420
			const yyr420 bool = false
			yyq420[0] = x.Type != ""
			yyq420[1] = x.RollingUpdate != nil
			if yyr420 || yy2arr420 {
				r.EncodeArrayStart(2)
			} else {
				var yynn420 int = 0
				for _, b := range yyq420 {
					if b {
						yynn420++
					}
				}
				r.EncodeMapStart(yynn420)
			}
			if yyr420 || yy2arr420 {
				if yyq420[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq420[0] {
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr420 || yy2arr420 {
				if yyq420[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq420[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yysep420 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym431 := z.EncBinary()
	_ = yym431
	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
	yym432 := z.DecBinary()
	_ = yym432
	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 {
		yym433 := z.EncBinary()
		_ = yym433
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep434 := !z.EncBinary()
			yy2arr434 := z.EncBasicHandle().StructToArray
			var yyq434 [3]bool
			_, _, _ = yysep434, yyq434, yy2arr434
			const yyr434 bool = false
			yyq434[0] = true
			yyq434[1] = true
			yyq434[2] = x.MinReadySeconds != 0
			if yyr434 || yy2arr434 {
				r.EncodeArrayStart(3)
			} else {
				var yynn434 int = 0
				for _, b := range yyq434 {
					if b {
						yynn434++
					}
				}
				r.EncodeMapStart(yynn434)
			}
			if yyr434 || yy2arr434 {
				if yyq434[0] {
					yy436 := &x.MaxUnavailable
					yym437 := z.EncBinary()
					_ = yym437
					if false {
					} else if z.HasExtensions() && z.EncExt(yy436) {
					} else if !yym437 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy436)
					} else {
						z.EncFallback(yy436)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq434[0] {
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					yy438 := &x.MaxUnavailable
					yym439 := z.EncBinary()
					_ = yym439
					if false {
					} else if z.HasExtensions() && z.EncExt(yy438) {
					} else if !yym439 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy438)
					} else {
						z.EncFallback(yy438)
					}
				}
			}
			if yyr434 || yy2arr434 {
				if yyq434[1] {
					yy441 := &x.MaxSurge
					yym442 := z.EncBinary()
					_ = yym442
					if false {
					} else if z.HasExtensions() && z.EncExt(yy441) {
					} else if !yym442 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy441)
					} else {
						z.EncFallback(yy441)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq434[1] {
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					yy443 := &x.MaxSurge
					yym444 := z.EncBinary()
					_ = yym444
					if false {
					} else if z.HasExtensions() && z.EncExt(yy443) {
					} else if !yym444 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy443)
					} else {
						z.EncFallback(yy443)
					}
				}
			}
			if yyr434 || yy2arr434 {
				if yyq434[2] {
					yym446 := z.EncBinary()
					_ = yym446
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq434[2] {
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					yym447 := z.EncBinary()
					_ = yym447
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yysep434 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj456 int
	var yyb456 bool
	var yyhl456 bool = l >= 0
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg6_util.IntOrString{}
	} else {
		yyv457 := &x.MaxUnavailable
		yym458 := z.DecBinary()
		_ = yym458
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv457) {
		} else if !yym458 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv457)
		} else {
			z.DecFallback(yyv457, false)
		}
	}
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxSurge = pkg6_util.IntOrString{}
	} else {
		yyv459 := &x.MaxSurge
		yym460 := z.DecBinary()
		_ = yym460
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv459) {
		} else if !yym460 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv459)
		} else {
			z.DecFallback(yyv459, false)
		}
	}
	yyj456++
	if yyhl456 {
		yyb456 = yyj456 > l
	} else {
		yyb456 = r.CheckBreak()
	}
	if yyb456 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj456++
		if yyhl456 {
			yyb456 = yyj456 > l
		} else {
			yyb456 = r.CheckBreak()
		}
		if yyb456 {
			break
		}
		z.DecStructFieldNotFound(yyj456-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 {
		yym462 := z.EncBinary()
		_ = yym462
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep463 := !z.EncBinary()
			yy2arr463 := z.EncBasicHandle().StructToArray
			var yyq463 [2]bool
			_, _, _ = yysep463, yyq463, yy2arr463
			const yyr463 bool = false
			yyq463[0] = x.Replicas != 0
			yyq463[1] = x.UpdatedReplicas != 0
			if yyr463 || yy2arr463 {
				r.EncodeArrayStart(2)
			} else {
				var yynn463 int = 0
				for _, b := range yyq463 {
					if b {
						yynn463++
					}
				}
				r.EncodeMapStart(yynn463)
			}
			if yyr463 || yy2arr463 {
				if yyq463[0] {
					yym465 := z.EncBinary()
					_ = yym465
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq463[0] {
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					yym466 := z.EncBinary()
					_ = yym466
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr463 || yy2arr463 {
				if yyq463[1] {
					yym468 := z.EncBinary()
					_ = yym468
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq463[1] {
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					yym469 := z.EncBinary()
					_ = yym469
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yysep463 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj475 int
	var yyb475 bool
	var yyhl475 bool = l >= 0
	yyj475++
	if yyhl475 {
		yyb475 = yyj475 > l
	} else {
		yyb475 = r.CheckBreak()
	}
	if yyb475 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj475++
	if yyhl475 {
		yyb475 = yyj475 > l
	} else {
		yyb475 = r.CheckBreak()
	}
	if yyb475 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj475++
		if yyhl475 {
			yyb475 = yyj475 > l
		} else {
			yyb475 = r.CheckBreak()
		}
		if yyb475 {
			break
		}
		z.DecStructFieldNotFound(yyj475-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 {
		yym478 := z.EncBinary()
		_ = yym478
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep479 := !z.EncBinary()
			yy2arr479 := z.EncBasicHandle().StructToArray
			var yyq479 [4]bool
			_, _, _ = yysep479, yyq479, yy2arr479
			const yyr479 bool = false
			yyq479[0] = x.Kind != ""
			yyq479[1] = x.APIVersion != ""
			yyq479[2] = true
			if yyr479 || yy2arr479 {
				r.EncodeArrayStart(4)
			} else {
				var yynn479 int = 1
				for _, b := range yyq479 {
					if b {
						yynn479++
					}
				}
				r.EncodeMapStart(yynn479)
			}
			if yyr479 || yy2arr479 {
				if yyq479[0] {
					yym481 := z.EncBinary()
					_ = yym481
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym482 := z.EncBinary()
					_ = yym482
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr479 || yy2arr479 {
				if yyq479[1] {
					yym484 := z.EncBinary()
					_ = yym484
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq479[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym485 := z.EncBinary()
					_ = yym485
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr479 || yy2arr479 {
				if yyq479[2] {
					yy487 := &x.ListMeta
					yym488 := z.EncBinary()
					_ = yym488
					if false {
					} else if z.HasExtensions() && z.EncExt(yy487) {
					} else {
						z.EncFallback(yy487)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq479[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy489 := &x.ListMeta
					yym490 := z.EncBinary()
					_ = yym490
					if false {
					} else if z.HasExtensions() && z.EncExt(yy489) {
					} else {
						z.EncFallback(yy489)
					}
				}
			}
			if yyr479 || yy2arr479 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym492 := z.EncBinary()
					_ = yym492
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym493 := z.EncBinary()
					_ = yym493
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yysep479 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj503 int
	var yyb503 bool
	var yyhl503 bool = l >= 0
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv506 := &x.ListMeta
		yym507 := z.DecBinary()
		_ = yym507
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv506) {
		} else {
			z.DecFallback(yyv506, false)
		}
	}
	yyj503++
	if yyhl503 {
		yyb503 = yyj503 > l
	} else {
		yyb503 = r.CheckBreak()
	}
	if yyb503 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv508 := &x.Items
		yym509 := z.DecBinary()
		_ = yym509
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv508), d)
		}
	}
	for {
		yyj503++
		if yyhl503 {
			yyb503 = yyj503 > l
		} else {
			yyb503 = r.CheckBreak()
		}
		if yyb503 {
			break
		}
		z.DecStructFieldNotFound(yyj503-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 {
		yym510 := z.EncBinary()
		_ = yym510
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep511 := !z.EncBinary()
			yy2arr511 := z.EncBasicHandle().StructToArray
			var yyq511 [2]bool
			_, _, _ = yysep511, yyq511, yy2arr511
			const yyr511 bool = false
			yyq511[0] = len(x.Selector) != 0
			yyq511[1] = x.Template != nil
			if yyr511 || yy2arr511 {
				r.EncodeArrayStart(2)
			} else {
				var yynn511 int = 0
				for _, b := range yyq511 {
					if b {
						yynn511++
					}
				}
				r.EncodeMapStart(yynn511)
			}
			if yyr511 || yy2arr511 {
				if yyq511[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym513 := z.EncBinary()
						_ = yym513
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq511[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym514 := z.EncBinary()
						_ = yym514
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr511 || yy2arr511 {
				if yyq511[1] {
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq511[1] {
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					if x.Template == nil {
						r.EncodeNil()
					} else {
						x.Template.CodecEncodeSelf(e)
					}
				}
			}
			if yysep511 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj522 int
	var yyb522 bool
	var yyhl522 bool = l >= 0
	yyj522++
	if yyhl522 {
		yyb522 = yyj522 > l
	} else {
		yyb522 = r.CheckBreak()
	}
	if yyb522 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv523 := &x.Selector
		yym524 := z.DecBinary()
		_ = yym524
		if false {
		} else {
			z.F.DecMapStringStringX(yyv523, false, d)
		}
	}
	yyj522++
	if yyhl522 {
		yyb522 = yyj522 > l
	} else {
		yyb522 = r.CheckBreak()
	}
	if yyb522 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Template != nil {
			x.Template = nil
		}
	} else {
		if x.Template == nil {
			x.Template = new(pkg2_api.PodTemplateSpec)
		}
		x.Template.CodecDecodeSelf(d)
	}
	for {
		yyj522++
		if yyhl522 {
			yyb522 = yyj522 > l
		} else {
			yyb522 = r.CheckBreak()
		}
		if yyb522 {
			break
		}
		z.DecStructFieldNotFound(yyj522-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 {
		yym526 := z.EncBinary()
		_ = yym526
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep527 := !z.EncBinary()
			yy2arr527 := z.EncBasicHandle().StructToArray
			var yyq527 [3]bool
			_, _, _ = yysep527, yyq527, yy2arr527
			const yyr527 bool = false
			if yyr527 || yy2arr527 {
				r.EncodeArrayStart(3)
			} else {
				var yynn527 int = 3
				for _, b := range yyq527 {
					if b {
						yynn527++
					}
				}
				r.EncodeMapStart(yynn527)
			}
			if yyr527 || yy2arr527 {
				yym529 := z.EncBinary()
				_ = yym529
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym530 := z.EncBinary()
				_ = yym530
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr527 || yy2arr527 {
				yym532 := z.EncBinary()
				_ = yym532
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym533 := z.EncBinary()
				_ = yym533
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr527 || yy2arr527 {
				yym535 := z.EncBinary()
				_ = yym535
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym536 := z.EncBinary()
				_ = yym536
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep527 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj543 int
	var yyb543 bool
	var yyhl543 bool = l >= 0
	yyj543++
	if yyhl543 {
		yyb543 = yyj543 > l
	} else {
		yyb543 = r.CheckBreak()
	}
	if yyb543 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj543++
	if yyhl543 {
		yyb543 = yyj543 > l
	} else {
		yyb543 = r.CheckBreak()
	}
	if yyb543 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj543++
	if yyhl543 {
		yyb543 = yyj543 > l
	} else {
		yyb543 = r.CheckBreak()
	}
	if yyb543 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj543++
		if yyhl543 {
			yyb543 = yyj543 > l
		} else {
			yyb543 = r.CheckBreak()
		}
		if yyb543 {
			break
		}
		z.DecStructFieldNotFound(yyj543-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 {
		yym547 := z.EncBinary()
		_ = yym547
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep548 := !z.EncBinary()
			yy2arr548 := z.EncBasicHandle().StructToArray
			var yyq548 [5]bool
			_, _, _ = yysep548, yyq548, yy2arr548
			const yyr548 bool = false
			yyq548[0] = x.Kind != ""
			yyq548[1] = x.APIVersion != ""
			yyq548[2] = true
			yyq548[3] = true
			yyq548[4] = true
			if yyr548 || yy2arr548 {
				r.EncodeArrayStart(5)
			} else {
				var yynn548 int = 0
				for _, b := range yyq548 {
					if b {
						yynn548++
					}
				}
				r.EncodeMapStart(yynn548)
			}
			if yyr548 || yy2arr548 {
				if yyq548[0] {
					yym550 := z.EncBinary()
					_ = yym550
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq548[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym551 := z.EncBinary()
					_ = yym551
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr548 || yy2arr548 {
				if yyq548[1] {
					yym553 := z.EncBinary()
					_ = yym553
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq548[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym554 := z.EncBinary()
					_ = yym554
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr548 || yy2arr548 {
				if yyq548[2] {
					yy556 := &x.ObjectMeta
					yy556.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq548[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy557 := &x.ObjectMeta
					yy557.CodecEncodeSelf(e)
				}
			}
			if yyr548 || yy2arr548 {
				if yyq548[3] {
					yy559 := &x.Spec
					yy559.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq548[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy560 := &x.Spec
					yy560.CodecEncodeSelf(e)
				}
			}
			if yyr548 || yy2arr548 {
				if yyq548[4] {
					yy562 := &x.Status
					yy562.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq548[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy563 := &x.Status
					yy563.CodecEncodeSelf(e)
				}
			}
			if yysep548 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj572 int
	var yyb572 bool
	var yyhl572 bool = l >= 0
	yyj572++
	if yyhl572 {
		yyb572 = yyj572 > l
	} else {
		yyb572 = r.CheckBreak()
	}
	if yyb572 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj572++
	if yyhl572 {
		yyb572 = yyj572 > l
	} else {
		yyb572 = r.CheckBreak()
	}
	if yyb572 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj572++
	if yyhl572 {
		yyb572 = yyj572 > l
	} else {
		yyb572 = r.CheckBreak()
	}
	if yyb572 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv575 := &x.ObjectMeta
		yyv575.CodecDecodeSelf(d)
	}
	yyj572++
	if yyhl572 {
		yyb572 = yyj572 > l
	} else {
		yyb572 = r.CheckBreak()
	}
	if yyb572 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv576 := &x.Spec
		yyv576.CodecDecodeSelf(d)
	}
	yyj572++
	if yyhl572 {
		yyb572 = yyj572 > l
	} else {
		yyb572 = r.CheckBreak()
	}
	if yyb572 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv577 := &x.Status
		yyv577.CodecDecodeSelf(d)
	}
	for {
		yyj572++
		if yyhl572 {
			yyb572 = yyj572 > l
		} else {
			yyb572 = r.CheckBreak()
		}
		if yyb572 {
			break
		}
		z.DecStructFieldNotFound(yyj572-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 {
		yym578 := z.EncBinary()
		_ = yym578
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep579 := !z.EncBinary()
			yy2arr579 := z.EncBasicHandle().StructToArray
			var yyq579 [4]bool
			_, _, _ = yysep579, yyq579, yy2arr579
			const yyr579 bool = false
			yyq579[0] = x.Kind != ""
			yyq579[1] = x.APIVersion != ""
			yyq579[2] = true
			if yyr579 || yy2arr579 {
				r.EncodeArrayStart(4)
			} else {
				var yynn579 int = 1
				for _, b := range yyq579 {
					if b {
						yynn579++
					}
				}
				r.EncodeMapStart(yynn579)
			}
			if yyr579 || yy2arr579 {
				if yyq579[0] {
					yym581 := z.EncBinary()
					_ = yym581
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq579[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym582 := z.EncBinary()
					_ = yym582
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr579 || yy2arr579 {
				if yyq579[1] {
					yym584 := z.EncBinary()
					_ = yym584
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq579[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym585 := z.EncBinary()
					_ = yym585
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr579 || yy2arr579 {
				if yyq579[2] {
					yy587 := &x.ListMeta
					yym588 := z.EncBinary()
					_ = yym588
					if false {
					} else if z.HasExtensions() && z.EncExt(yy587) {
					} else {
						z.EncFallback(yy587)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq579[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy589 := &x.ListMeta
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else if z.HasExtensions() && z.EncExt(yy589) {
					} else {
						z.EncFallback(yy589)
					}
				}
			}
			if yyr579 || yy2arr579 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep579 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj603 int
	var yyb603 bool
	var yyhl603 bool = l >= 0
	yyj603++
	if yyhl603 {
		yyb603 = yyj603 > l
	} else {
		yyb603 = r.CheckBreak()
	}
	if yyb603 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj603++
	if yyhl603 {
		yyb603 = yyj603 > l
	} else {
		yyb603 = r.CheckBreak()
	}
	if yyb603 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj603++
	if yyhl603 {
		yyb603 = yyj603 > l
	} else {
		yyb603 = r.CheckBreak()
	}
	if yyb603 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv606 := &x.ListMeta
		yym607 := z.DecBinary()
		_ = yym607
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv606) {
		} else {
			z.DecFallback(yyv606, false)
		}
	}
	yyj603++
	if yyhl603 {
		yyb603 = yyj603 > l
	} else {
		yyb603 = r.CheckBreak()
	}
	if yyb603 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv608 := &x.Items
		yym609 := z.DecBinary()
		_ = yym609
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv608), d)
		}
	}
	for {
		yyj603++
		if yyhl603 {
			yyb603 = yyj603 > l
		} else {
			yyb603 = r.CheckBreak()
		}
		if yyb603 {
			break
		}
		z.DecStructFieldNotFound(yyj603-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 {
		yym610 := z.EncBinary()
		_ = yym610
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep611 := !z.EncBinary()
			yy2arr611 := z.EncBasicHandle().StructToArray
			var yyq611 [4]bool
			_, _, _ = yysep611, yyq611, yy2arr611
			const yyr611 bool = false
			yyq611[0] = x.Kind != ""
			yyq611[1] = x.APIVersion != ""
			yyq611[2] = true
			if yyr611 || yy2arr611 {
				r.EncodeArrayStart(4)
			} else {
				var yynn611 int = 1
				for _, b := range yyq611 {
					if b {
						yynn611++
					}
				}
				r.EncodeMapStart(yynn611)
			}
			if yyr611 || yy2arr611 {
				if yyq611[0] {
					yym613 := z.EncBinary()
					_ = yym613
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq611[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym614 := z.EncBinary()
					_ = yym614
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr611 || yy2arr611 {
				if yyq611[1] {
					yym616 := z.EncBinary()
					_ = yym616
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq611[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym617 := z.EncBinary()
					_ = yym617
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr611 || yy2arr611 {
				if yyq611[2] {
					yy619 := &x.ListMeta
					yym620 := z.EncBinary()
					_ = yym620
					if false {
					} else if z.HasExtensions() && z.EncExt(yy619) {
					} else {
						z.EncFallback(yy619)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq611[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy621 := &x.ListMeta
					yym622 := z.EncBinary()
					_ = yym622
					if false {
					} else if z.HasExtensions() && z.EncExt(yy621) {
					} else {
						z.EncFallback(yy621)
					}
				}
			}
			if yyr611 || yy2arr611 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym624 := z.EncBinary()
					_ = yym624
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym625 := z.EncBinary()
					_ = yym625
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep611 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj635 int
	var yyb635 bool
	var yyhl635 bool = l >= 0
	yyj635++
	if yyhl635 {
		yyb635 = yyj635 > l
	} else {
		yyb635 = r.CheckBreak()
	}
	if yyb635 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj635++
	if yyhl635 {
		yyb635 = yyj635 > l
	} else {
		yyb635 = r.CheckBreak()
	}
	if yyb635 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj635++
	if yyhl635 {
		yyb635 = yyj635 > l
	} else {
		yyb635 = r.CheckBreak()
	}
	if yyb635 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv638 := &x.ListMeta
		yym639 := z.DecBinary()
		_ = yym639
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv638) {
		} else {
			z.DecFallback(yyv638, false)
		}
	}
	yyj635++
	if yyhl635 {
		yyb635 = yyj635 > l
	} else {
		yyb635 = r.CheckBreak()
	}
	if yyb635 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv640 := &x.Items
		yym641 := z.DecBinary()
		_ = yym641
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv640), d)
		}
	}
	for {
		yyj635++
		if yyhl635 {
			yyb635 = yyj635 > l
		} else {
			yyb635 = r.CheckBreak()
		}
		if yyb635 {
			break
		}
		z.DecStructFieldNotFound(yyj635-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 {
		yym642 := z.EncBinary()
		_ = yym642
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep643 := !z.EncBinary()
			yy2arr643 := z.EncBasicHandle().StructToArray
			var yyq643 [5]bool
			_, _, _ = yysep643, yyq643, yy2arr643
			const yyr643 bool = false
			yyq643[0] = x.Kind != ""
			yyq643[1] = x.APIVersion != ""
			yyq643[2] = true
			yyq643[3] = true
			yyq643[4] = true
			if yyr643 || yy2arr643 {
				r.EncodeArrayStart(5)
			} else {
				var yynn643 int = 0
				for _, b := range yyq643 {
					if b {
						yynn643++
					}
				}
				r.EncodeMapStart(yynn643)
			}
			if yyr643 || yy2arr643 {
				if yyq643[0] {
					yym645 := z.EncBinary()
					_ = yym645
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq643[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym646 := z.EncBinary()
					_ = yym646
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr643 || yy2arr643 {
				if yyq643[1] {
					yym648 := z.EncBinary()
					_ = yym648
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq643[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym649 := z.EncBinary()
					_ = yym649
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr643 || yy2arr643 {
				if yyq643[2] {
					yy651 := &x.ObjectMeta
					yy651.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq643[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy652 := &x.ObjectMeta
					yy652.CodecEncodeSelf(e)
				}
			}
			if yyr643 || yy2arr643 {
				if yyq643[3] {
					yy654 := &x.Spec
					yy654.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq643[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy655 := &x.Spec
					yy655.CodecEncodeSelf(e)
				}
			}
			if yyr643 || yy2arr643 {
				if yyq643[4] {
					yy657 := &x.Status
					yy657.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq643[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy658 := &x.Status
					yy658.CodecEncodeSelf(e)
				}
			}
			if yysep643 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj667 int
	var yyb667 bool
	var yyhl667 bool = l >= 0
	yyj667++
	if yyhl667 {
		yyb667 = yyj667 > l
	} else {
		yyb667 = r.CheckBreak()
	}
	if yyb667 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj667++
	if yyhl667 {
		yyb667 = yyj667 > l
	} else {
		yyb667 = r.CheckBreak()
	}
	if yyb667 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj667++
	if yyhl667 {
		yyb667 = yyj667 > l
	} else {
		yyb667 = r.CheckBreak()
	}
	if yyb667 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv670 := &x.ObjectMeta
		yyv670.CodecDecodeSelf(d)
	}
	yyj667++
	if yyhl667 {
		yyb667 = yyj667 > l
	} else {
		yyb667 = r.CheckBreak()
	}
	if yyb667 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv671 := &x.Spec
		yyv671.CodecDecodeSelf(d)
	}
	yyj667++
	if yyhl667 {
		yyb667 = yyj667 > l
	} else {
		yyb667 = r.CheckBreak()
	}
	if yyb667 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv672 := &x.Status
		yyv672.CodecDecodeSelf(d)
	}
	for {
		yyj667++
		if yyhl667 {
			yyb667 = yyj667 > l
		} else {
			yyb667 = r.CheckBreak()
		}
		if yyb667 {
			break
		}
		z.DecStructFieldNotFound(yyj667-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 {
		yym673 := z.EncBinary()
		_ = yym673
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep674 := !z.EncBinary()
			yy2arr674 := z.EncBasicHandle().StructToArray
			var yyq674 [4]bool
			_, _, _ = yysep674, yyq674, yy2arr674
			const yyr674 bool = false
			yyq674[0] = x.Kind != ""
			yyq674[1] = x.APIVersion != ""
			yyq674[2] = true
			if yyr674 || yy2arr674 {
				r.EncodeArrayStart(4)
			} else {
				var yynn674 int = 1
				for _, b := range yyq674 {
					if b {
						yynn674++
					}
				}
				r.EncodeMapStart(yynn674)
			}
			if yyr674 || yy2arr674 {
				if yyq674[0] {
					yym676 := z.EncBinary()
					_ = yym676
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq674[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym677 := z.EncBinary()
					_ = yym677
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr674 || yy2arr674 {
				if yyq674[1] {
					yym679 := z.EncBinary()
					_ = yym679
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq674[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym680 := z.EncBinary()
					_ = yym680
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr674 || yy2arr674 {
				if yyq674[2] {
					yy682 := &x.ListMeta
					yym683 := z.EncBinary()
					_ = yym683
					if false {
					} else if z.HasExtensions() && z.EncExt(yy682) {
					} else {
						z.EncFallback(yy682)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq674[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy684 := &x.ListMeta
					yym685 := z.EncBinary()
					_ = yym685
					if false {
					} else if z.HasExtensions() && z.EncExt(yy684) {
					} else {
						z.EncFallback(yy684)
					}
				}
			}
			if yyr674 || yy2arr674 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym687 := z.EncBinary()
					_ = yym687
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym688 := z.EncBinary()
					_ = yym688
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep674 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj698 int
	var yyb698 bool
	var yyhl698 bool = l >= 0
	yyj698++
	if yyhl698 {
		yyb698 = yyj698 > l
	} else {
		yyb698 = r.CheckBreak()
	}
	if yyb698 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj698++
	if yyhl698 {
		yyb698 = yyj698 > l
	} else {
		yyb698 = r.CheckBreak()
	}
	if yyb698 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj698++
	if yyhl698 {
		yyb698 = yyj698 > l
	} else {
		yyb698 = r.CheckBreak()
	}
	if yyb698 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv701 := &x.ListMeta
		yym702 := z.DecBinary()
		_ = yym702
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv701) {
		} else {
			z.DecFallback(yyv701, false)
		}
	}
	yyj698++
	if yyhl698 {
		yyb698 = yyj698 > l
	} else {
		yyb698 = r.CheckBreak()
	}
	if yyb698 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv703 := &x.Items
		yym704 := z.DecBinary()
		_ = yym704
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv703), d)
		}
	}
	for {
		yyj698++
		if yyhl698 {
			yyb698 = yyj698 > l
		} else {
			yyb698 = r.CheckBreak()
		}
		if yyb698 {
			break
		}
		z.DecStructFieldNotFound(yyj698-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 {
		yym705 := z.EncBinary()
		_ = yym705
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep706 := !z.EncBinary()
			yy2arr706 := z.EncBasicHandle().StructToArray
			var yyq706 [4]bool
			_, _, _ = yysep706, yyq706, yy2arr706
			const yyr706 bool = false
			yyq706[0] = x.Parallelism != nil
			yyq706[1] = x.Completions != nil
			yyq706[2] = x.Selector != nil
			if yyr706 || yy2arr706 {
				r.EncodeArrayStart(4)
			} else {
				var yynn706 int = 1
				for _, b := range yyq706 {
					if b {
						yynn706++
					}
				}
				r.EncodeMapStart(yynn706)
			}
			if yyr706 || yy2arr706 {
				if yyq706[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy708 := *x.Parallelism
						yym709 := z.EncBinary()
						_ = yym709
						if false {
						} else {
							r.EncodeInt(int64(yy708))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq706[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy710 := *x.Parallelism
						yym711 := z.EncBinary()
						_ = yym711
						if false {
						} else {
							r.EncodeInt(int64(yy710))
						}
					}
				}
			}
			if yyr706 || yy2arr706 {
				if yyq706[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy713 := *x.Completions
						yym714 := z.EncBinary()
						_ = yym714
						if false {
						} else {
							r.EncodeInt(int64(yy713))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq706[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy715 := *x.Completions
						yym716 := z.EncBinary()
						_ = yym716
						if false {
						} else {
							r.EncodeInt(int64(yy715))
						}
					}
				}
			}
			if yyr706 || yy2arr706 {
				if yyq706[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq706[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr706 || yy2arr706 {
				yy719 := &x.Template
				yy719.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy720 := &x.Template
				yy720.CodecEncodeSelf(e)
			}
			if yysep706 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj730 int
	var yyb730 bool
	var yyhl730 bool = l >= 0
	yyj730++
	if yyhl730 {
		yyb730 = yyj730 > l
	} else {
		yyb730 = r.CheckBreak()
	}
	if yyb730 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int)
		}
		yym732 := z.DecBinary()
		_ = yym732
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj730++
	if yyhl730 {
		yyb730 = yyj730 > l
	} else {
		yyb730 = r.CheckBreak()
	}
	if yyb730 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int)
		}
		yym734 := z.DecBinary()
		_ = yym734
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj730++
	if yyhl730 {
		yyb730 = yyj730 > l
	} else {
		yyb730 = r.CheckBreak()
	}
	if yyb730 {
		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)
	}
	yyj730++
	if yyhl730 {
		yyb730 = yyj730 > l
	} else {
		yyb730 = r.CheckBreak()
	}
	if yyb730 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv736 := &x.Template
		yyv736.CodecDecodeSelf(d)
	}
	for {
		yyj730++
		if yyhl730 {
			yyb730 = yyj730 > l
		} else {
			yyb730 = r.CheckBreak()
		}
		if yyb730 {
			break
		}
		z.DecStructFieldNotFound(yyj730-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 {
		yym737 := z.EncBinary()
		_ = yym737
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep738 := !z.EncBinary()
			yy2arr738 := z.EncBasicHandle().StructToArray
			var yyq738 [6]bool
			_, _, _ = yysep738, yyq738, yy2arr738
			const yyr738 bool = false
			yyq738[0] = len(x.Conditions) != 0
			yyq738[1] = x.StartTime != nil
			yyq738[2] = x.CompletionTime != nil
			yyq738[3] = x.Active != 0
			yyq738[4] = x.Succeeded != 0
			yyq738[5] = x.Failed != 0
			if yyr738 || yy2arr738 {
				r.EncodeArrayStart(6)
			} else {
				var yynn738 int = 0
				for _, b := range yyq738 {
					if b {
						yynn738++
					}
				}
				r.EncodeMapStart(yynn738)
			}
			if yyr738 || yy2arr738 {
				if yyq738[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym740 := z.EncBinary()
						_ = yym740
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq738[0] {
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym741 := z.EncBinary()
						_ = yym741
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr738 || yy2arr738 {
				if yyq738[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym743 := z.EncBinary()
						_ = yym743
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym743 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym743 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq738[1] {
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym744 := z.EncBinary()
						_ = yym744
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym744 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym744 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr738 || yy2arr738 {
				if yyq738[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym746 := z.EncBinary()
						_ = yym746
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym746 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym746 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq738[2] {
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym747 := z.EncBinary()
						_ = yym747
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym747 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym747 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr738 || yy2arr738 {
				if yyq738[3] {
					yym749 := z.EncBinary()
					_ = yym749
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq738[3] {
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					yym750 := z.EncBinary()
					_ = yym750
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr738 || yy2arr738 {
				if yyq738[4] {
					yym752 := z.EncBinary()
					_ = yym752
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq738[4] {
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					yym753 := z.EncBinary()
					_ = yym753
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr738 || yy2arr738 {
				if yyq738[5] {
					yym755 := z.EncBinary()
					_ = yym755
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq738[5] {
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					yym756 := z.EncBinary()
					_ = yym756
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yysep738 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym779 := z.EncBinary()
	_ = yym779
	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
	yym780 := z.DecBinary()
	_ = yym780
	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 {
		yym781 := z.EncBinary()
		_ = yym781
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep782 := !z.EncBinary()
			yy2arr782 := z.EncBasicHandle().StructToArray
			var yyq782 [6]bool
			_, _, _ = yysep782, yyq782, yy2arr782
			const yyr782 bool = false
			yyq782[2] = true
			yyq782[3] = true
			yyq782[4] = x.Reason != ""
			yyq782[5] = x.Message != ""
			if yyr782 || yy2arr782 {
				r.EncodeArrayStart(6)
			} else {
				var yynn782 int = 2
				for _, b := range yyq782 {
					if b {
						yynn782++
					}
				}
				r.EncodeMapStart(yynn782)
			}
			if yyr782 || yy2arr782 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr782 || yy2arr782 {
				yym785 := z.EncBinary()
				_ = yym785
				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"))
				yym786 := z.EncBinary()
				_ = yym786
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr782 || yy2arr782 {
				if yyq782[2] {
					yy788 := &x.LastProbeTime
					yym789 := z.EncBinary()
					_ = yym789
					if false {
					} else if z.HasExtensions() && z.EncExt(yy788) {
					} else if yym789 {
						z.EncBinaryMarshal(yy788)
					} else if !yym789 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy788)
					} else {
						z.EncFallback(yy788)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq782[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy790 := &x.LastProbeTime
					yym791 := z.EncBinary()
					_ = yym791
					if false {
					} else if z.HasExtensions() && z.EncExt(yy790) {
					} else if yym791 {
						z.EncBinaryMarshal(yy790)
					} else if !yym791 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy790)
					} else {
						z.EncFallback(yy790)
					}
				}
			}
			if yyr782 || yy2arr782 {
				if yyq782[3] {
					yy793 := &x.LastTransitionTime
					yym794 := z.EncBinary()
					_ = yym794
					if false {
					} else if z.HasExtensions() && z.EncExt(yy793) {
					} else if yym794 {
						z.EncBinaryMarshal(yy793)
					} else if !yym794 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy793)
					} else {
						z.EncFallback(yy793)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq782[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy795 := &x.LastTransitionTime
					yym796 := z.EncBinary()
					_ = yym796
					if false {
					} else if z.HasExtensions() && z.EncExt(yy795) {
					} else if yym796 {
						z.EncBinaryMarshal(yy795)
					} else if !yym796 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy795)
					} else {
						z.EncFallback(yy795)
					}
				}
			}
			if yyr782 || yy2arr782 {
				if yyq782[4] {
					yym798 := z.EncBinary()
					_ = yym798
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq782[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym799 := z.EncBinary()
					_ = yym799
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr782 || yy2arr782 {
				if yyq782[5] {
					yym801 := z.EncBinary()
					_ = yym801
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq782[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym802 := z.EncBinary()
					_ = yym802
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep782 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj814 int
	var yyb814 bool
	var yyhl814 bool = l >= 0
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_api.ConditionStatus(r.DecodeString())
	}
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv817 := &x.LastProbeTime
		yym818 := z.DecBinary()
		_ = yym818
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv817) {
		} else if yym818 {
			z.DecBinaryUnmarshal(yyv817)
		} else if !yym818 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv817)
		} else {
			z.DecFallback(yyv817, false)
		}
	}
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv819 := &x.LastTransitionTime
		yym820 := z.DecBinary()
		_ = yym820
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv819) {
		} else if yym820 {
			z.DecBinaryUnmarshal(yyv819)
		} else if !yym820 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv819)
		} else {
			z.DecFallback(yyv819, false)
		}
	}
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj814++
	if yyhl814 {
		yyb814 = yyj814 > l
	} else {
		yyb814 = r.CheckBreak()
	}
	if yyb814 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj814++
		if yyhl814 {
			yyb814 = yyj814 > l
		} else {
			yyb814 = r.CheckBreak()
		}
		if yyb814 {
			break
		}
		z.DecStructFieldNotFound(yyj814-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 {
		yym823 := z.EncBinary()
		_ = yym823
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep824 := !z.EncBinary()
			yy2arr824 := z.EncBasicHandle().StructToArray
			var yyq824 [5]bool
			_, _, _ = yysep824, yyq824, yy2arr824
			const yyr824 bool = false
			yyq824[0] = x.Kind != ""
			yyq824[1] = x.APIVersion != ""
			yyq824[2] = true
			yyq824[3] = true
			yyq824[4] = true
			if yyr824 || yy2arr824 {
				r.EncodeArrayStart(5)
			} else {
				var yynn824 int = 0
				for _, b := range yyq824 {
					if b {
						yynn824++
					}
				}
				r.EncodeMapStart(yynn824)
			}
			if yyr824 || yy2arr824 {
				if yyq824[0] {
					yym826 := z.EncBinary()
					_ = yym826
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq824[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym827 := z.EncBinary()
					_ = yym827
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr824 || yy2arr824 {
				if yyq824[1] {
					yym829 := z.EncBinary()
					_ = yym829
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq824[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym830 := z.EncBinary()
					_ = yym830
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr824 || yy2arr824 {
				if yyq824[2] {
					yy832 := &x.ObjectMeta
					yy832.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq824[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy833 := &x.ObjectMeta
					yy833.CodecEncodeSelf(e)
				}
			}
			if yyr824 || yy2arr824 {
				if yyq824[3] {
					yy835 := &x.Spec
					yy835.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq824[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy836 := &x.Spec
					yy836.CodecEncodeSelf(e)
				}
			}
			if yyr824 || yy2arr824 {
				if yyq824[4] {
					yy838 := &x.Status
					yy838.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq824[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy839 := &x.Status
					yy839.CodecEncodeSelf(e)
				}
			}
			if yysep824 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj848 int
	var yyb848 bool
	var yyhl848 bool = l >= 0
	yyj848++
	if yyhl848 {
		yyb848 = yyj848 > l
	} else {
		yyb848 = r.CheckBreak()
	}
	if yyb848 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj848++
	if yyhl848 {
		yyb848 = yyj848 > l
	} else {
		yyb848 = r.CheckBreak()
	}
	if yyb848 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj848++
	if yyhl848 {
		yyb848 = yyj848 > l
	} else {
		yyb848 = r.CheckBreak()
	}
	if yyb848 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv851 := &x.ObjectMeta
		yyv851.CodecDecodeSelf(d)
	}
	yyj848++
	if yyhl848 {
		yyb848 = yyj848 > l
	} else {
		yyb848 = r.CheckBreak()
	}
	if yyb848 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv852 := &x.Spec
		yyv852.CodecDecodeSelf(d)
	}
	yyj848++
	if yyhl848 {
		yyb848 = yyj848 > l
	} else {
		yyb848 = r.CheckBreak()
	}
	if yyb848 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv853 := &x.Status
		yyv853.CodecDecodeSelf(d)
	}
	for {
		yyj848++
		if yyhl848 {
			yyb848 = yyj848 > l
		} else {
			yyb848 = r.CheckBreak()
		}
		if yyb848 {
			break
		}
		z.DecStructFieldNotFound(yyj848-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 {
		yym854 := z.EncBinary()
		_ = yym854
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep855 := !z.EncBinary()
			yy2arr855 := z.EncBasicHandle().StructToArray
			var yyq855 [4]bool
			_, _, _ = yysep855, yyq855, yy2arr855
			const yyr855 bool = false
			yyq855[0] = x.Kind != ""
			yyq855[1] = x.APIVersion != ""
			yyq855[2] = true
			if yyr855 || yy2arr855 {
				r.EncodeArrayStart(4)
			} else {
				var yynn855 int = 1
				for _, b := range yyq855 {
					if b {
						yynn855++
					}
				}
				r.EncodeMapStart(yynn855)
			}
			if yyr855 || yy2arr855 {
				if yyq855[0] {
					yym857 := z.EncBinary()
					_ = yym857
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq855[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym858 := z.EncBinary()
					_ = yym858
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr855 || yy2arr855 {
				if yyq855[1] {
					yym860 := z.EncBinary()
					_ = yym860
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq855[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym861 := z.EncBinary()
					_ = yym861
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr855 || yy2arr855 {
				if yyq855[2] {
					yy863 := &x.ListMeta
					yym864 := z.EncBinary()
					_ = yym864
					if false {
					} else if z.HasExtensions() && z.EncExt(yy863) {
					} else {
						z.EncFallback(yy863)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq855[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy865 := &x.ListMeta
					yym866 := z.EncBinary()
					_ = yym866
					if false {
					} else if z.HasExtensions() && z.EncExt(yy865) {
					} else {
						z.EncFallback(yy865)
					}
				}
			}
			if yyr855 || yy2arr855 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym868 := z.EncBinary()
					_ = yym868
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym869 := z.EncBinary()
					_ = yym869
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep855 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj879 int
	var yyb879 bool
	var yyhl879 bool = l >= 0
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv882 := &x.ListMeta
		yym883 := z.DecBinary()
		_ = yym883
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv882) {
		} else {
			z.DecFallback(yyv882, false)
		}
	}
	yyj879++
	if yyhl879 {
		yyb879 = yyj879 > l
	} else {
		yyb879 = r.CheckBreak()
	}
	if yyb879 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv884 := &x.Items
		yym885 := z.DecBinary()
		_ = yym885
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv884), d)
		}
	}
	for {
		yyj879++
		if yyhl879 {
			yyb879 = yyj879 > l
		} else {
			yyb879 = r.CheckBreak()
		}
		if yyb879 {
			break
		}
		z.DecStructFieldNotFound(yyj879-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 {
		yym886 := z.EncBinary()
		_ = yym886
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep887 := !z.EncBinary()
			yy2arr887 := z.EncBasicHandle().StructToArray
			var yyq887 [2]bool
			_, _, _ = yysep887, yyq887, yy2arr887
			const yyr887 bool = false
			yyq887[0] = x.Backend != nil
			yyq887[1] = len(x.Rules) != 0
			if yyr887 || yy2arr887 {
				r.EncodeArrayStart(2)
			} else {
				var yynn887 int = 0
				for _, b := range yyq887 {
					if b {
						yynn887++
					}
				}
				r.EncodeMapStart(yynn887)
			}
			if yyr887 || yy2arr887 {
				if yyq887[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq887[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr887 || yy2arr887 {
				if yyq887[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym890 := z.EncBinary()
						_ = yym890
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq887[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym891 := z.EncBinary()
						_ = yym891
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep887 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj898 int
	var yyb898 bool
	var yyhl898 bool = l >= 0
	yyj898++
	if yyhl898 {
		yyb898 = yyj898 > l
	} else {
		yyb898 = r.CheckBreak()
	}
	if yyb898 {
		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)
	}
	yyj898++
	if yyhl898 {
		yyb898 = yyj898 > l
	} else {
		yyb898 = r.CheckBreak()
	}
	if yyb898 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv900 := &x.Rules
		yym901 := z.DecBinary()
		_ = yym901
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv900), d)
		}
	}
	for {
		yyj898++
		if yyhl898 {
			yyb898 = yyj898 > l
		} else {
			yyb898 = r.CheckBreak()
		}
		if yyb898 {
			break
		}
		z.DecStructFieldNotFound(yyj898-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 {
		yym902 := z.EncBinary()
		_ = yym902
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep903 := !z.EncBinary()
			yy2arr903 := z.EncBasicHandle().StructToArray
			var yyq903 [1]bool
			_, _, _ = yysep903, yyq903, yy2arr903
			const yyr903 bool = false
			yyq903[0] = true
			if yyr903 || yy2arr903 {
				r.EncodeArrayStart(1)
			} else {
				var yynn903 int = 0
				for _, b := range yyq903 {
					if b {
						yynn903++
					}
				}
				r.EncodeMapStart(yynn903)
			}
			if yyr903 || yy2arr903 {
				if yyq903[0] {
					yy905 := &x.LoadBalancer
					yy905.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq903[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy906 := &x.LoadBalancer
					yy906.CodecEncodeSelf(e)
				}
			}
			if yysep903 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj911 int
	var yyb911 bool
	var yyhl911 bool = l >= 0
	yyj911++
	if yyhl911 {
		yyb911 = yyj911 > l
	} else {
		yyb911 = r.CheckBreak()
	}
	if yyb911 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv912 := &x.LoadBalancer
		yyv912.CodecDecodeSelf(d)
	}
	for {
		yyj911++
		if yyhl911 {
			yyb911 = yyj911 > l
		} else {
			yyb911 = r.CheckBreak()
		}
		if yyb911 {
			break
		}
		z.DecStructFieldNotFound(yyj911-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 {
		yym913 := z.EncBinary()
		_ = yym913
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep914 := !z.EncBinary()
			yy2arr914 := z.EncBasicHandle().StructToArray
			var yyq914 [2]bool
			_, _, _ = yysep914, yyq914, yy2arr914
			const yyr914 bool = false
			yyq914[0] = x.Host != ""
			yyq914[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr914 || yy2arr914 {
				r.EncodeArrayStart(2)
			} else {
				var yynn914 int = 0
				for _, b := range yyq914 {
					if b {
						yynn914++
					}
				}
				r.EncodeMapStart(yynn914)
			}
			if yyr914 || yy2arr914 {
				if yyq914[0] {
					yym916 := z.EncBinary()
					_ = yym916
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq914[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym917 := z.EncBinary()
					_ = yym917
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn918 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn918 = true
				goto LABEL918
			}
		LABEL918:
			if yyr914 || yy2arr914 {
				if yyn918 {
					r.EncodeNil()
				} else {
					if yyq914[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq914[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn918 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep914 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj934 int
	var yyb934 bool
	var yyhl934 bool = l >= 0
	yyj934++
	if yyhl934 {
		yyb934 = yyj934 > l
	} else {
		yyb934 = r.CheckBreak()
	}
	if yyb934 {
		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 {
		yyj934++
		if yyhl934 {
			yyb934 = yyj934 > l
		} else {
			yyb934 = r.CheckBreak()
		}
		if yyb934 {
			break
		}
		z.DecStructFieldNotFound(yyj934-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 {
		yym936 := z.EncBinary()
		_ = yym936
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep937 := !z.EncBinary()
			yy2arr937 := z.EncBasicHandle().StructToArray
			var yyq937 [1]bool
			_, _, _ = yysep937, yyq937, yy2arr937
			const yyr937 bool = false
			if yyr937 || yy2arr937 {
				r.EncodeArrayStart(1)
			} else {
				var yynn937 int = 1
				for _, b := range yyq937 {
					if b {
						yynn937++
					}
				}
				r.EncodeMapStart(yynn937)
			}
			if yyr937 || yy2arr937 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym939 := z.EncBinary()
					_ = yym939
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym940 := z.EncBinary()
					_ = yym940
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep937 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj946 int
	var yyb946 bool
	var yyhl946 bool = l >= 0
	yyj946++
	if yyhl946 {
		yyb946 = yyj946 > l
	} else {
		yyb946 = r.CheckBreak()
	}
	if yyb946 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv947 := &x.Paths
		yym948 := z.DecBinary()
		_ = yym948
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv947), d)
		}
	}
	for {
		yyj946++
		if yyhl946 {
			yyb946 = yyj946 > l
		} else {
			yyb946 = r.CheckBreak()
		}
		if yyb946 {
			break
		}
		z.DecStructFieldNotFound(yyj946-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 {
		yym949 := z.EncBinary()
		_ = yym949
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep950 := !z.EncBinary()
			yy2arr950 := z.EncBasicHandle().StructToArray
			var yyq950 [2]bool
			_, _, _ = yysep950, yyq950, yy2arr950
			const yyr950 bool = false
			yyq950[0] = x.Path != ""
			if yyr950 || yy2arr950 {
				r.EncodeArrayStart(2)
			} else {
				var yynn950 int = 1
				for _, b := range yyq950 {
					if b {
						yynn950++
					}
				}
				r.EncodeMapStart(yynn950)
			}
			if yyr950 || yy2arr950 {
				if yyq950[0] {
					yym952 := z.EncBinary()
					_ = yym952
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq950[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym953 := z.EncBinary()
					_ = yym953
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr950 || yy2arr950 {
				yy955 := &x.Backend
				yy955.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy956 := &x.Backend
				yy956.CodecEncodeSelf(e)
			}
			if yysep950 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj962 int
	var yyb962 bool
	var yyhl962 bool = l >= 0
	yyj962++
	if yyhl962 {
		yyb962 = yyj962 > l
	} else {
		yyb962 = r.CheckBreak()
	}
	if yyb962 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj962++
	if yyhl962 {
		yyb962 = yyj962 > l
	} else {
		yyb962 = r.CheckBreak()
	}
	if yyb962 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv964 := &x.Backend
		yyv964.CodecDecodeSelf(d)
	}
	for {
		yyj962++
		if yyhl962 {
			yyb962 = yyj962 > l
		} else {
			yyb962 = r.CheckBreak()
		}
		if yyb962 {
			break
		}
		z.DecStructFieldNotFound(yyj962-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 {
		yym965 := z.EncBinary()
		_ = yym965
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep966 := !z.EncBinary()
			yy2arr966 := z.EncBasicHandle().StructToArray
			var yyq966 [2]bool
			_, _, _ = yysep966, yyq966, yy2arr966
			const yyr966 bool = false
			if yyr966 || yy2arr966 {
				r.EncodeArrayStart(2)
			} else {
				var yynn966 int = 2
				for _, b := range yyq966 {
					if b {
						yynn966++
					}
				}
				r.EncodeMapStart(yynn966)
			}
			if yyr966 || yy2arr966 {
				yym968 := z.EncBinary()
				_ = yym968
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym969 := z.EncBinary()
				_ = yym969
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr966 || yy2arr966 {
				yy971 := &x.ServicePort
				yym972 := z.EncBinary()
				_ = yym972
				if false {
				} else if z.HasExtensions() && z.EncExt(yy971) {
				} else if !yym972 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy971)
				} else {
					z.EncFallback(yy971)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy973 := &x.ServicePort
				yym974 := z.EncBinary()
				_ = yym974
				if false {
				} else if z.HasExtensions() && z.EncExt(yy973) {
				} else if !yym974 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy973)
				} else {
					z.EncFallback(yy973)
				}
			}
			if yysep966 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj981 int
	var yyb981 bool
	var yyhl981 bool = l >= 0
	yyj981++
	if yyhl981 {
		yyb981 = yyj981 > l
	} else {
		yyb981 = r.CheckBreak()
	}
	if yyb981 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj981++
	if yyhl981 {
		yyb981 = yyj981 > l
	} else {
		yyb981 = r.CheckBreak()
	}
	if yyb981 {
		r.ReadEnd()
		return
	}
	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)
		}
	}
	for {
		yyj981++
		if yyhl981 {
			yyb981 = yyj981 > l
		} else {
			yyb981 = r.CheckBreak()
		}
		if yyb981 {
			break
		}
		z.DecStructFieldNotFound(yyj981-1, "")
	}
	r.ReadEnd()
}

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

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

func (x *NodeUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj998 int
	var yyb998 bool
	var yyhl998 bool = l >= 0
	yyj998++
	if yyhl998 {
		yyb998 = yyj998 > l
	} else {
		yyb998 = r.CheckBreak()
	}
	if yyb998 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj998++
	if yyhl998 {
		yyb998 = yyj998 > l
	} else {
		yyb998 = r.CheckBreak()
	}
	if yyb998 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj998++
		if yyhl998 {
			yyb998 = yyj998 > l
		} else {
			yyb998 = r.CheckBreak()
		}
		if yyb998 {
			break
		}
		z.DecStructFieldNotFound(yyj998-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 {
		yym1001 := z.EncBinary()
		_ = yym1001
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1002 := !z.EncBinary()
			yy2arr1002 := z.EncBasicHandle().StructToArray
			var yyq1002 [3]bool
			_, _, _ = yysep1002, yyq1002, yy2arr1002
			const yyr1002 bool = false
			if yyr1002 || yy2arr1002 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1002 int = 3
				for _, b := range yyq1002 {
					if b {
						yynn1002++
					}
				}
				r.EncodeMapStart(yynn1002)
			}
			if yyr1002 || yy2arr1002 {
				yym1004 := z.EncBinary()
				_ = yym1004
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				yym1005 := z.EncBinary()
				_ = yym1005
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr1002 || yy2arr1002 {
				yym1007 := z.EncBinary()
				_ = yym1007
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				yym1008 := z.EncBinary()
				_ = yym1008
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr1002 || yy2arr1002 {
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1010 := z.EncBinary()
					_ = yym1010
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1011 := z.EncBinary()
					_ = yym1011
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yysep1002 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1019 int
	var yyb1019 bool
	var yyhl1019 bool = l >= 0
	yyj1019++
	if yyhl1019 {
		yyb1019 = yyj1019 > l
	} else {
		yyb1019 = r.CheckBreak()
	}
	if yyb1019 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1019++
	if yyhl1019 {
		yyb1019 = yyj1019 > l
	} else {
		yyb1019 = r.CheckBreak()
	}
	if yyb1019 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1019++
	if yyhl1019 {
		yyb1019 = yyj1019 > l
	} else {
		yyb1019 = r.CheckBreak()
	}
	if yyb1019 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1022 := &x.TargetUtilization
		yym1023 := z.DecBinary()
		_ = yym1023
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1022), d)
		}
	}
	for {
		yyj1019++
		if yyhl1019 {
			yyb1019 = yyj1019 > l
		} else {
			yyb1019 = r.CheckBreak()
		}
		if yyb1019 {
			break
		}
		z.DecStructFieldNotFound(yyj1019-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 {
		yym1024 := z.EncBinary()
		_ = yym1024
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1025 := !z.EncBinary()
			yy2arr1025 := z.EncBasicHandle().StructToArray
			var yyq1025 [4]bool
			_, _, _ = yysep1025, yyq1025, yy2arr1025
			const yyr1025 bool = false
			yyq1025[0] = x.Kind != ""
			yyq1025[1] = x.APIVersion != ""
			yyq1025[2] = true
			yyq1025[3] = true
			if yyr1025 || yy2arr1025 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1025 int = 0
				for _, b := range yyq1025 {
					if b {
						yynn1025++
					}
				}
				r.EncodeMapStart(yynn1025)
			}
			if yyr1025 || yy2arr1025 {
				if yyq1025[0] {
					yym1027 := z.EncBinary()
					_ = yym1027
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1025[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1028 := z.EncBinary()
					_ = yym1028
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1025 || yy2arr1025 {
				if yyq1025[1] {
					yym1030 := z.EncBinary()
					_ = yym1030
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1025[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1031 := z.EncBinary()
					_ = yym1031
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1025 || yy2arr1025 {
				if yyq1025[2] {
					yy1033 := &x.ObjectMeta
					yy1033.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1025[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1034 := &x.ObjectMeta
					yy1034.CodecEncodeSelf(e)
				}
			}
			if yyr1025 || yy2arr1025 {
				if yyq1025[3] {
					yy1036 := &x.Spec
					yy1036.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1025[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1037 := &x.Spec
					yy1037.CodecEncodeSelf(e)
				}
			}
			if yysep1025 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1045 int
	var yyb1045 bool
	var yyhl1045 bool = l >= 0
	yyj1045++
	if yyhl1045 {
		yyb1045 = yyj1045 > l
	} else {
		yyb1045 = r.CheckBreak()
	}
	if yyb1045 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1045++
	if yyhl1045 {
		yyb1045 = yyj1045 > l
	} else {
		yyb1045 = r.CheckBreak()
	}
	if yyb1045 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1045++
	if yyhl1045 {
		yyb1045 = yyj1045 > l
	} else {
		yyb1045 = r.CheckBreak()
	}
	if yyb1045 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1048 := &x.ObjectMeta
		yyv1048.CodecDecodeSelf(d)
	}
	yyj1045++
	if yyhl1045 {
		yyb1045 = yyj1045 > l
	} else {
		yyb1045 = r.CheckBreak()
	}
	if yyb1045 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1049 := &x.Spec
		yyv1049.CodecDecodeSelf(d)
	}
	for {
		yyj1045++
		if yyhl1045 {
			yyb1045 = yyj1045 > l
		} else {
			yyb1045 = r.CheckBreak()
		}
		if yyb1045 {
			break
		}
		z.DecStructFieldNotFound(yyj1045-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 {
		yym1050 := z.EncBinary()
		_ = yym1050
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1051 := !z.EncBinary()
			yy2arr1051 := z.EncBasicHandle().StructToArray
			var yyq1051 [4]bool
			_, _, _ = yysep1051, yyq1051, yy2arr1051
			const yyr1051 bool = false
			yyq1051[0] = x.Kind != ""
			yyq1051[1] = x.APIVersion != ""
			yyq1051[2] = true
			if yyr1051 || yy2arr1051 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1051 int = 1
				for _, b := range yyq1051 {
					if b {
						yynn1051++
					}
				}
				r.EncodeMapStart(yynn1051)
			}
			if yyr1051 || yy2arr1051 {
				if yyq1051[0] {
					yym1053 := z.EncBinary()
					_ = yym1053
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1051[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1054 := z.EncBinary()
					_ = yym1054
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1051 || yy2arr1051 {
				if yyq1051[1] {
					yym1056 := z.EncBinary()
					_ = yym1056
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1051[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1057 := z.EncBinary()
					_ = yym1057
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1051 || yy2arr1051 {
				if yyq1051[2] {
					yy1059 := &x.ListMeta
					yym1060 := z.EncBinary()
					_ = yym1060
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1059) {
					} else {
						z.EncFallback(yy1059)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1051[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1061 := &x.ListMeta
					yym1062 := z.EncBinary()
					_ = yym1062
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1061) {
					} else {
						z.EncFallback(yy1061)
					}
				}
			}
			if yyr1051 || yy2arr1051 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1064 := z.EncBinary()
					_ = yym1064
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1065 := z.EncBinary()
					_ = yym1065
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1051 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1075 int
	var yyb1075 bool
	var yyhl1075 bool = l >= 0
	yyj1075++
	if yyhl1075 {
		yyb1075 = yyj1075 > l
	} else {
		yyb1075 = r.CheckBreak()
	}
	if yyb1075 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1075++
	if yyhl1075 {
		yyb1075 = yyj1075 > l
	} else {
		yyb1075 = r.CheckBreak()
	}
	if yyb1075 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1075++
	if yyhl1075 {
		yyb1075 = yyj1075 > l
	} else {
		yyb1075 = r.CheckBreak()
	}
	if yyb1075 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1078 := &x.ListMeta
		yym1079 := z.DecBinary()
		_ = yym1079
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1078) {
		} else {
			z.DecFallback(yyv1078, false)
		}
	}
	yyj1075++
	if yyhl1075 {
		yyb1075 = yyj1075 > l
	} else {
		yyb1075 = r.CheckBreak()
	}
	if yyb1075 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1080 := &x.Items
		yym1081 := z.DecBinary()
		_ = yym1081
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1080), d)
		}
	}
	for {
		yyj1075++
		if yyhl1075 {
			yyb1075 = yyj1075 > l
		} else {
			yyb1075 = r.CheckBreak()
		}
		if yyb1075 {
			break
		}
		z.DecStructFieldNotFound(yyj1075-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 {
		yym1082 := z.EncBinary()
		_ = yym1082
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1083 := !z.EncBinary()
			yy2arr1083 := z.EncBasicHandle().StructToArray
			var yyq1083 [2]bool
			_, _, _ = yysep1083, yyq1083, yy2arr1083
			const yyr1083 bool = false
			yyq1083[0] = len(x.MatchLabels) != 0
			yyq1083[1] = len(x.MatchExpressions) != 0
			if yyr1083 || yy2arr1083 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1083 int = 0
				for _, b := range yyq1083 {
					if b {
						yynn1083++
					}
				}
				r.EncodeMapStart(yynn1083)
			}
			if yyr1083 || yy2arr1083 {
				if yyq1083[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1085 := z.EncBinary()
						_ = yym1085
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1083[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1086 := z.EncBinary()
						_ = yym1086
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1083 || yy2arr1083 {
				if yyq1083[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1088 := z.EncBinary()
						_ = yym1088
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1083[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1089 := z.EncBinary()
						_ = yym1089
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1083 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1097 int
	var yyb1097 bool
	var yyhl1097 bool = l >= 0
	yyj1097++
	if yyhl1097 {
		yyb1097 = yyj1097 > l
	} else {
		yyb1097 = r.CheckBreak()
	}
	if yyb1097 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1098 := &x.MatchLabels
		yym1099 := z.DecBinary()
		_ = yym1099
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1098, false, d)
		}
	}
	yyj1097++
	if yyhl1097 {
		yyb1097 = yyj1097 > l
	} else {
		yyb1097 = r.CheckBreak()
	}
	if yyb1097 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1100 := &x.MatchExpressions
		yym1101 := z.DecBinary()
		_ = yym1101
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1100), d)
		}
	}
	for {
		yyj1097++
		if yyhl1097 {
			yyb1097 = yyj1097 > l
		} else {
			yyb1097 = r.CheckBreak()
		}
		if yyb1097 {
			break
		}
		z.DecStructFieldNotFound(yyj1097-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 {
		yym1102 := z.EncBinary()
		_ = yym1102
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1103 := !z.EncBinary()
			yy2arr1103 := z.EncBasicHandle().StructToArray
			var yyq1103 [3]bool
			_, _, _ = yysep1103, yyq1103, yy2arr1103
			const yyr1103 bool = false
			yyq1103[2] = len(x.Values) != 0
			if yyr1103 || yy2arr1103 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1103 int = 2
				for _, b := range yyq1103 {
					if b {
						yynn1103++
					}
				}
				r.EncodeMapStart(yynn1103)
			}
			if yyr1103 || yy2arr1103 {
				yym1105 := z.EncBinary()
				_ = yym1105
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1106 := z.EncBinary()
				_ = yym1106
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1103 || yy2arr1103 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1103 || yy2arr1103 {
				if yyq1103[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1109 := z.EncBinary()
						_ = yym1109
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1103[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1110 := z.EncBinary()
						_ = yym1110
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1103 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

	yyv1127 := *v
	yyh1127, yyl1127 := z.DecSliceHelperStart()

	var yyrr1127, yyrl1127 int
	var yyc1127, yyrt1127 bool
	_, _, _ = yyc1127, yyrt1127, yyrl1127
	yyrr1127 = yyl1127

	if yyv1127 == nil {
		if yyrl1127, yyrt1127 = z.DecInferLen(yyl1127, z.DecBasicHandle().MaxInitLen, 320); yyrt1127 {
			yyrr1127 = yyrl1127
		}
		yyv1127 = make([]HorizontalPodAutoscaler, yyrl1127)
		yyc1127 = true
	}

	if yyl1127 == 0 {
		if len(yyv1127) != 0 {
			yyv1127 = yyv1127[:0]
			yyc1127 = true
		}
	} else if yyl1127 > 0 {

		if yyl1127 > cap(yyv1127) {
			yyrl1127, yyrt1127 = z.DecInferLen(yyl1127, z.DecBasicHandle().MaxInitLen, 320)
			yyv1127 = make([]HorizontalPodAutoscaler, yyrl1127)
			yyc1127 = true

			yyrr1127 = len(yyv1127)
		} else if yyl1127 != len(yyv1127) {
			yyv1127 = yyv1127[:yyl1127]
			yyc1127 = true
		}
		yyj1127 := 0
		for ; yyj1127 < yyrr1127; yyj1127++ {
			if r.TryDecodeAsNil() {
				yyv1127[yyj1127] = HorizontalPodAutoscaler{}
			} else {
				yyv1128 := &yyv1127[yyj1127]
				yyv1128.CodecDecodeSelf(d)
			}

		}
		if yyrt1127 {
			for ; yyj1127 < yyl1127; yyj1127++ {
				yyv1127 = append(yyv1127, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1127[yyj1127] = HorizontalPodAutoscaler{}
				} else {
					yyv1129 := &yyv1127[yyj1127]
					yyv1129.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1127 := 0; !r.CheckBreak(); yyj1127++ {
			if yyj1127 >= len(yyv1127) {
				yyv1127 = append(yyv1127, HorizontalPodAutoscaler{}) // var yyz1127 HorizontalPodAutoscaler
				yyc1127 = true
			}

			if yyj1127 < len(yyv1127) {
				if r.TryDecodeAsNil() {
					yyv1127[yyj1127] = HorizontalPodAutoscaler{}
				} else {
					yyv1130 := &yyv1127[yyj1127]
					yyv1130.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1127.End()
	}
	if yyc1127 {
		*v = yyv1127
	}

}

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

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

	yyv1133 := *v
	yyh1133, yyl1133 := z.DecSliceHelperStart()

	var yyrr1133, yyrl1133 int
	var yyc1133, yyrt1133 bool
	_, _, _ = yyc1133, yyrt1133, yyrl1133
	yyrr1133 = yyl1133

	if yyv1133 == nil {
		if yyrl1133, yyrt1133 = z.DecInferLen(yyl1133, z.DecBasicHandle().MaxInitLen, 32); yyrt1133 {
			yyrr1133 = yyrl1133
		}
		yyv1133 = make([]APIVersion, yyrl1133)
		yyc1133 = true
	}

	if yyl1133 == 0 {
		if len(yyv1133) != 0 {
			yyv1133 = yyv1133[:0]
			yyc1133 = true
		}
	} else if yyl1133 > 0 {

		if yyl1133 > cap(yyv1133) {
			yyrl1133, yyrt1133 = z.DecInferLen(yyl1133, z.DecBasicHandle().MaxInitLen, 32)
			yyv1133 = make([]APIVersion, yyrl1133)
			yyc1133 = true

			yyrr1133 = len(yyv1133)
		} else if yyl1133 != len(yyv1133) {
			yyv1133 = yyv1133[:yyl1133]
			yyc1133 = true
		}
		yyj1133 := 0
		for ; yyj1133 < yyrr1133; yyj1133++ {
			if r.TryDecodeAsNil() {
				yyv1133[yyj1133] = APIVersion{}
			} else {
				yyv1134 := &yyv1133[yyj1133]
				yyv1134.CodecDecodeSelf(d)
			}

		}
		if yyrt1133 {
			for ; yyj1133 < yyl1133; yyj1133++ {
				yyv1133 = append(yyv1133, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1133[yyj1133] = APIVersion{}
				} else {
					yyv1135 := &yyv1133[yyj1133]
					yyv1135.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1133 := 0; !r.CheckBreak(); yyj1133++ {
			if yyj1133 >= len(yyv1133) {
				yyv1133 = append(yyv1133, APIVersion{}) // var yyz1133 APIVersion
				yyc1133 = true
			}

			if yyj1133 < len(yyv1133) {
				if r.TryDecodeAsNil() {
					yyv1133[yyj1133] = APIVersion{}
				} else {
					yyv1136 := &yyv1133[yyj1133]
					yyv1136.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1133.End()
	}
	if yyc1133 {
		*v = yyv1133
	}

}

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

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

	yyv1139 := *v
	yyh1139, yyl1139 := z.DecSliceHelperStart()

	var yyrr1139, yyrl1139 int
	var yyc1139, yyrt1139 bool
	_, _, _ = yyc1139, yyrt1139, yyrl1139
	yyrr1139 = yyl1139

	if yyv1139 == nil {
		if yyrl1139, yyrt1139 = z.DecInferLen(yyl1139, z.DecBasicHandle().MaxInitLen, 232); yyrt1139 {
			yyrr1139 = yyrl1139
		}
		yyv1139 = make([]ThirdPartyResource, yyrl1139)
		yyc1139 = true
	}

	if yyl1139 == 0 {
		if len(yyv1139) != 0 {
			yyv1139 = yyv1139[:0]
			yyc1139 = true
		}
	} else if yyl1139 > 0 {

		if yyl1139 > cap(yyv1139) {
			yyrl1139, yyrt1139 = z.DecInferLen(yyl1139, z.DecBasicHandle().MaxInitLen, 232)
			yyv1139 = make([]ThirdPartyResource, yyrl1139)
			yyc1139 = true

			yyrr1139 = len(yyv1139)
		} else if yyl1139 != len(yyv1139) {
			yyv1139 = yyv1139[:yyl1139]
			yyc1139 = true
		}
		yyj1139 := 0
		for ; yyj1139 < yyrr1139; yyj1139++ {
			if r.TryDecodeAsNil() {
				yyv1139[yyj1139] = ThirdPartyResource{}
			} else {
				yyv1140 := &yyv1139[yyj1139]
				yyv1140.CodecDecodeSelf(d)
			}

		}
		if yyrt1139 {
			for ; yyj1139 < yyl1139; yyj1139++ {
				yyv1139 = append(yyv1139, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1139[yyj1139] = ThirdPartyResource{}
				} else {
					yyv1141 := &yyv1139[yyj1139]
					yyv1141.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1139 := 0; !r.CheckBreak(); yyj1139++ {
			if yyj1139 >= len(yyv1139) {
				yyv1139 = append(yyv1139, ThirdPartyResource{}) // var yyz1139 ThirdPartyResource
				yyc1139 = true
			}

			if yyj1139 < len(yyv1139) {
				if r.TryDecodeAsNil() {
					yyv1139[yyj1139] = ThirdPartyResource{}
				} else {
					yyv1142 := &yyv1139[yyj1139]
					yyv1142.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1139.End()
	}
	if yyc1139 {
		*v = yyv1139
	}

}

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

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

	yyv1145 := *v
	yyh1145, yyl1145 := z.DecSliceHelperStart()

	var yyrr1145, yyrl1145 int
	var yyc1145, yyrt1145 bool
	_, _, _ = yyc1145, yyrt1145, yyrl1145
	yyrr1145 = yyl1145

	if yyv1145 == nil {
		if yyrl1145, yyrt1145 = z.DecInferLen(yyl1145, z.DecBasicHandle().MaxInitLen, 592); yyrt1145 {
			yyrr1145 = yyrl1145
		}
		yyv1145 = make([]Deployment, yyrl1145)
		yyc1145 = true
	}

	if yyl1145 == 0 {
		if len(yyv1145) != 0 {
			yyv1145 = yyv1145[:0]
			yyc1145 = true
		}
	} else if yyl1145 > 0 {

		if yyl1145 > cap(yyv1145) {
			yyrl1145, yyrt1145 = z.DecInferLen(yyl1145, z.DecBasicHandle().MaxInitLen, 592)
			yyv1145 = make([]Deployment, yyrl1145)
			yyc1145 = true

			yyrr1145 = len(yyv1145)
		} else if yyl1145 != len(yyv1145) {
			yyv1145 = yyv1145[:yyl1145]
			yyc1145 = true
		}
		yyj1145 := 0
		for ; yyj1145 < yyrr1145; yyj1145++ {
			if r.TryDecodeAsNil() {
				yyv1145[yyj1145] = Deployment{}
			} else {
				yyv1146 := &yyv1145[yyj1145]
				yyv1146.CodecDecodeSelf(d)
			}

		}
		if yyrt1145 {
			for ; yyj1145 < yyl1145; yyj1145++ {
				yyv1145 = append(yyv1145, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1145[yyj1145] = Deployment{}
				} else {
					yyv1147 := &yyv1145[yyj1145]
					yyv1147.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1145 := 0; !r.CheckBreak(); yyj1145++ {
			if yyj1145 >= len(yyv1145) {
				yyv1145 = append(yyv1145, Deployment{}) // var yyz1145 Deployment
				yyc1145 = true
			}

			if yyj1145 < len(yyv1145) {
				if r.TryDecodeAsNil() {
					yyv1145[yyj1145] = Deployment{}
				} else {
					yyv1148 := &yyv1145[yyj1145]
					yyv1148.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1145.End()
	}
	if yyc1145 {
		*v = yyv1145
	}

}

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

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

	yyv1151 := *v
	yyh1151, yyl1151 := z.DecSliceHelperStart()

	var yyrr1151, yyrl1151 int
	var yyc1151, yyrt1151 bool
	_, _, _ = yyc1151, yyrt1151, yyrl1151
	yyrr1151 = yyl1151

	if yyv1151 == nil {
		if yyrl1151, yyrt1151 = z.DecInferLen(yyl1151, z.DecBasicHandle().MaxInitLen, 232); yyrt1151 {
			yyrr1151 = yyrl1151
		}
		yyv1151 = make([]DaemonSet, yyrl1151)
		yyc1151 = true
	}

	if yyl1151 == 0 {
		if len(yyv1151) != 0 {
			yyv1151 = yyv1151[:0]
			yyc1151 = true
		}
	} else if yyl1151 > 0 {

		if yyl1151 > cap(yyv1151) {
			yyrl1151, yyrt1151 = z.DecInferLen(yyl1151, z.DecBasicHandle().MaxInitLen, 232)
			yyv1151 = make([]DaemonSet, yyrl1151)
			yyc1151 = true

			yyrr1151 = len(yyv1151)
		} else if yyl1151 != len(yyv1151) {
			yyv1151 = yyv1151[:yyl1151]
			yyc1151 = true
		}
		yyj1151 := 0
		for ; yyj1151 < yyrr1151; yyj1151++ {
			if r.TryDecodeAsNil() {
				yyv1151[yyj1151] = DaemonSet{}
			} else {
				yyv1152 := &yyv1151[yyj1151]
				yyv1152.CodecDecodeSelf(d)
			}

		}
		if yyrt1151 {
			for ; yyj1151 < yyl1151; yyj1151++ {
				yyv1151 = append(yyv1151, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1151[yyj1151] = DaemonSet{}
				} else {
					yyv1153 := &yyv1151[yyj1151]
					yyv1153.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1151 := 0; !r.CheckBreak(); yyj1151++ {
			if yyj1151 >= len(yyv1151) {
				yyv1151 = append(yyv1151, DaemonSet{}) // var yyz1151 DaemonSet
				yyc1151 = true
			}

			if yyj1151 < len(yyv1151) {
				if r.TryDecodeAsNil() {
					yyv1151[yyj1151] = DaemonSet{}
				} else {
					yyv1154 := &yyv1151[yyj1151]
					yyv1154.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1151.End()
	}
	if yyc1151 {
		*v = yyv1151
	}

}

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

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

	yyv1157 := *v
	yyh1157, yyl1157 := z.DecSliceHelperStart()

	var yyrr1157, yyrl1157 int
	var yyc1157, yyrt1157 bool
	_, _, _ = yyc1157, yyrt1157, yyrl1157
	yyrr1157 = yyl1157

	if yyv1157 == nil {
		if yyrl1157, yyrt1157 = z.DecInferLen(yyl1157, z.DecBasicHandle().MaxInitLen, 216); yyrt1157 {
			yyrr1157 = yyrl1157
		}
		yyv1157 = make([]ThirdPartyResourceData, yyrl1157)
		yyc1157 = true
	}

	if yyl1157 == 0 {
		if len(yyv1157) != 0 {
			yyv1157 = yyv1157[:0]
			yyc1157 = true
		}
	} else if yyl1157 > 0 {

		if yyl1157 > cap(yyv1157) {
			yyrl1157, yyrt1157 = z.DecInferLen(yyl1157, z.DecBasicHandle().MaxInitLen, 216)
			yyv1157 = make([]ThirdPartyResourceData, yyrl1157)
			yyc1157 = true

			yyrr1157 = len(yyv1157)
		} else if yyl1157 != len(yyv1157) {
			yyv1157 = yyv1157[:yyl1157]
			yyc1157 = true
		}
		yyj1157 := 0
		for ; yyj1157 < yyrr1157; yyj1157++ {
			if r.TryDecodeAsNil() {
				yyv1157[yyj1157] = ThirdPartyResourceData{}
			} else {
				yyv1158 := &yyv1157[yyj1157]
				yyv1158.CodecDecodeSelf(d)
			}

		}
		if yyrt1157 {
			for ; yyj1157 < yyl1157; yyj1157++ {
				yyv1157 = append(yyv1157, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1157[yyj1157] = ThirdPartyResourceData{}
				} else {
					yyv1159 := &yyv1157[yyj1157]
					yyv1159.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1157 := 0; !r.CheckBreak(); yyj1157++ {
			if yyj1157 >= len(yyv1157) {
				yyv1157 = append(yyv1157, ThirdPartyResourceData{}) // var yyz1157 ThirdPartyResourceData
				yyc1157 = true
			}

			if yyj1157 < len(yyv1157) {
				if r.TryDecodeAsNil() {
					yyv1157[yyj1157] = ThirdPartyResourceData{}
				} else {
					yyv1160 := &yyv1157[yyj1157]
					yyv1160.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1157.End()
	}
	if yyc1157 {
		*v = yyv1157
	}

}

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

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

	yyv1163 := *v
	yyh1163, yyl1163 := z.DecSliceHelperStart()

	var yyrr1163, yyrl1163 int
	var yyc1163, yyrt1163 bool
	_, _, _ = yyc1163, yyrt1163, yyrl1163
	yyrr1163 = yyl1163

	if yyv1163 == nil {
		if yyrl1163, yyrt1163 = z.DecInferLen(yyl1163, z.DecBasicHandle().MaxInitLen, 608); yyrt1163 {
			yyrr1163 = yyrl1163
		}
		yyv1163 = make([]Job, yyrl1163)
		yyc1163 = true
	}

	if yyl1163 == 0 {
		if len(yyv1163) != 0 {
			yyv1163 = yyv1163[:0]
			yyc1163 = true
		}
	} else if yyl1163 > 0 {

		if yyl1163 > cap(yyv1163) {
			yyrl1163, yyrt1163 = z.DecInferLen(yyl1163, z.DecBasicHandle().MaxInitLen, 608)
			yyv1163 = make([]Job, yyrl1163)
			yyc1163 = true

			yyrr1163 = len(yyv1163)
		} else if yyl1163 != len(yyv1163) {
			yyv1163 = yyv1163[:yyl1163]
			yyc1163 = true
		}
		yyj1163 := 0
		for ; yyj1163 < yyrr1163; yyj1163++ {
			if r.TryDecodeAsNil() {
				yyv1163[yyj1163] = Job{}
			} else {
				yyv1164 := &yyv1163[yyj1163]
				yyv1164.CodecDecodeSelf(d)
			}

		}
		if yyrt1163 {
			for ; yyj1163 < yyl1163; yyj1163++ {
				yyv1163 = append(yyv1163, Job{})
				if r.TryDecodeAsNil() {
					yyv1163[yyj1163] = Job{}
				} else {
					yyv1165 := &yyv1163[yyj1163]
					yyv1165.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1163 := 0; !r.CheckBreak(); yyj1163++ {
			if yyj1163 >= len(yyv1163) {
				yyv1163 = append(yyv1163, Job{}) // var yyz1163 Job
				yyc1163 = true
			}

			if yyj1163 < len(yyv1163) {
				if r.TryDecodeAsNil() {
					yyv1163[yyj1163] = Job{}
				} else {
					yyv1166 := &yyv1163[yyj1163]
					yyv1166.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1163.End()
	}
	if yyc1163 {
		*v = yyv1163
	}

}

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

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

	yyv1169 := *v
	yyh1169, yyl1169 := z.DecSliceHelperStart()

	var yyrr1169, yyrl1169 int
	var yyc1169, yyrt1169 bool
	_, _, _ = yyc1169, yyrt1169, yyrl1169
	yyrr1169 = yyl1169

	if yyv1169 == nil {
		if yyrl1169, yyrt1169 = z.DecInferLen(yyl1169, z.DecBasicHandle().MaxInitLen, 112); yyrt1169 {
			yyrr1169 = yyrl1169
		}
		yyv1169 = make([]JobCondition, yyrl1169)
		yyc1169 = true
	}

	if yyl1169 == 0 {
		if len(yyv1169) != 0 {
			yyv1169 = yyv1169[:0]
			yyc1169 = true
		}
	} else if yyl1169 > 0 {

		if yyl1169 > cap(yyv1169) {
			yyrl1169, yyrt1169 = z.DecInferLen(yyl1169, z.DecBasicHandle().MaxInitLen, 112)
			yyv1169 = make([]JobCondition, yyrl1169)
			yyc1169 = true

			yyrr1169 = len(yyv1169)
		} else if yyl1169 != len(yyv1169) {
			yyv1169 = yyv1169[:yyl1169]
			yyc1169 = true
		}
		yyj1169 := 0
		for ; yyj1169 < yyrr1169; yyj1169++ {
			if r.TryDecodeAsNil() {
				yyv1169[yyj1169] = JobCondition{}
			} else {
				yyv1170 := &yyv1169[yyj1169]
				yyv1170.CodecDecodeSelf(d)
			}

		}
		if yyrt1169 {
			for ; yyj1169 < yyl1169; yyj1169++ {
				yyv1169 = append(yyv1169, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1169[yyj1169] = JobCondition{}
				} else {
					yyv1171 := &yyv1169[yyj1169]
					yyv1171.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1169 := 0; !r.CheckBreak(); yyj1169++ {
			if yyj1169 >= len(yyv1169) {
				yyv1169 = append(yyv1169, JobCondition{}) // var yyz1169 JobCondition
				yyc1169 = true
			}

			if yyj1169 < len(yyv1169) {
				if r.TryDecodeAsNil() {
					yyv1169[yyj1169] = JobCondition{}
				} else {
					yyv1172 := &yyv1169[yyj1169]
					yyv1172.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1169.End()
	}
	if yyc1169 {
		*v = yyv1169
	}

}

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

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

	yyv1175 := *v
	yyh1175, yyl1175 := z.DecSliceHelperStart()

	var yyrr1175, yyrl1175 int
	var yyc1175, yyrt1175 bool
	_, _, _ = yyc1175, yyrt1175, yyrl1175
	yyrr1175 = yyl1175

	if yyv1175 == nil {
		if yyrl1175, yyrt1175 = z.DecInferLen(yyl1175, z.DecBasicHandle().MaxInitLen, 248); yyrt1175 {
			yyrr1175 = yyrl1175
		}
		yyv1175 = make([]Ingress, yyrl1175)
		yyc1175 = true
	}

	if yyl1175 == 0 {
		if len(yyv1175) != 0 {
			yyv1175 = yyv1175[:0]
			yyc1175 = true
		}
	} else if yyl1175 > 0 {

		if yyl1175 > cap(yyv1175) {
			yyrl1175, yyrt1175 = z.DecInferLen(yyl1175, z.DecBasicHandle().MaxInitLen, 248)
			yyv1175 = make([]Ingress, yyrl1175)
			yyc1175 = true

			yyrr1175 = len(yyv1175)
		} else if yyl1175 != len(yyv1175) {
			yyv1175 = yyv1175[:yyl1175]
			yyc1175 = true
		}
		yyj1175 := 0
		for ; yyj1175 < yyrr1175; yyj1175++ {
			if r.TryDecodeAsNil() {
				yyv1175[yyj1175] = Ingress{}
			} else {
				yyv1176 := &yyv1175[yyj1175]
				yyv1176.CodecDecodeSelf(d)
			}

		}
		if yyrt1175 {
			for ; yyj1175 < yyl1175; yyj1175++ {
				yyv1175 = append(yyv1175, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1175[yyj1175] = Ingress{}
				} else {
					yyv1177 := &yyv1175[yyj1175]
					yyv1177.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1175 := 0; !r.CheckBreak(); yyj1175++ {
			if yyj1175 >= len(yyv1175) {
				yyv1175 = append(yyv1175, Ingress{}) // var yyz1175 Ingress
				yyc1175 = true
			}

			if yyj1175 < len(yyv1175) {
				if r.TryDecodeAsNil() {
					yyv1175[yyj1175] = Ingress{}
				} else {
					yyv1178 := &yyv1175[yyj1175]
					yyv1178.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1175.End()
	}
	if yyc1175 {
		*v = yyv1175
	}

}

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

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

	yyv1181 := *v
	yyh1181, yyl1181 := z.DecSliceHelperStart()

	var yyrr1181, yyrl1181 int
	var yyc1181, yyrt1181 bool
	_, _, _ = yyc1181, yyrt1181, yyrl1181
	yyrr1181 = yyl1181

	if yyv1181 == nil {
		if yyrl1181, yyrt1181 = z.DecInferLen(yyl1181, z.DecBasicHandle().MaxInitLen, 24); yyrt1181 {
			yyrr1181 = yyrl1181
		}
		yyv1181 = make([]IngressRule, yyrl1181)
		yyc1181 = true
	}

	if yyl1181 == 0 {
		if len(yyv1181) != 0 {
			yyv1181 = yyv1181[:0]
			yyc1181 = true
		}
	} else if yyl1181 > 0 {

		if yyl1181 > cap(yyv1181) {
			yyrl1181, yyrt1181 = z.DecInferLen(yyl1181, z.DecBasicHandle().MaxInitLen, 24)
			yyv1181 = make([]IngressRule, yyrl1181)
			yyc1181 = true

			yyrr1181 = len(yyv1181)
		} else if yyl1181 != len(yyv1181) {
			yyv1181 = yyv1181[:yyl1181]
			yyc1181 = true
		}
		yyj1181 := 0
		for ; yyj1181 < yyrr1181; yyj1181++ {
			if r.TryDecodeAsNil() {
				yyv1181[yyj1181] = IngressRule{}
			} else {
				yyv1182 := &yyv1181[yyj1181]
				yyv1182.CodecDecodeSelf(d)
			}

		}
		if yyrt1181 {
			for ; yyj1181 < yyl1181; yyj1181++ {
				yyv1181 = append(yyv1181, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1181[yyj1181] = IngressRule{}
				} else {
					yyv1183 := &yyv1181[yyj1181]
					yyv1183.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1181 := 0; !r.CheckBreak(); yyj1181++ {
			if yyj1181 >= len(yyv1181) {
				yyv1181 = append(yyv1181, IngressRule{}) // var yyz1181 IngressRule
				yyc1181 = true
			}

			if yyj1181 < len(yyv1181) {
				if r.TryDecodeAsNil() {
					yyv1181[yyj1181] = IngressRule{}
				} else {
					yyv1184 := &yyv1181[yyj1181]
					yyv1184.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1181.End()
	}
	if yyc1181 {
		*v = yyv1181
	}

}

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

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

	yyv1187 := *v
	yyh1187, yyl1187 := z.DecSliceHelperStart()

	var yyrr1187, yyrl1187 int
	var yyc1187, yyrt1187 bool
	_, _, _ = yyc1187, yyrt1187, yyrl1187
	yyrr1187 = yyl1187

	if yyv1187 == nil {
		if yyrl1187, yyrt1187 = z.DecInferLen(yyl1187, z.DecBasicHandle().MaxInitLen, 64); yyrt1187 {
			yyrr1187 = yyrl1187
		}
		yyv1187 = make([]HTTPIngressPath, yyrl1187)
		yyc1187 = true
	}

	if yyl1187 == 0 {
		if len(yyv1187) != 0 {
			yyv1187 = yyv1187[:0]
			yyc1187 = true
		}
	} else if yyl1187 > 0 {

		if yyl1187 > cap(yyv1187) {
			yyrl1187, yyrt1187 = z.DecInferLen(yyl1187, z.DecBasicHandle().MaxInitLen, 64)
			yyv1187 = make([]HTTPIngressPath, yyrl1187)
			yyc1187 = true

			yyrr1187 = len(yyv1187)
		} else if yyl1187 != len(yyv1187) {
			yyv1187 = yyv1187[:yyl1187]
			yyc1187 = true
		}
		yyj1187 := 0
		for ; yyj1187 < yyrr1187; yyj1187++ {
			if r.TryDecodeAsNil() {
				yyv1187[yyj1187] = HTTPIngressPath{}
			} else {
				yyv1188 := &yyv1187[yyj1187]
				yyv1188.CodecDecodeSelf(d)
			}

		}
		if yyrt1187 {
			for ; yyj1187 < yyl1187; yyj1187++ {
				yyv1187 = append(yyv1187, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1187[yyj1187] = HTTPIngressPath{}
				} else {
					yyv1189 := &yyv1187[yyj1187]
					yyv1189.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1187 := 0; !r.CheckBreak(); yyj1187++ {
			if yyj1187 >= len(yyv1187) {
				yyv1187 = append(yyv1187, HTTPIngressPath{}) // var yyz1187 HTTPIngressPath
				yyc1187 = true
			}

			if yyj1187 < len(yyv1187) {
				if r.TryDecodeAsNil() {
					yyv1187[yyj1187] = HTTPIngressPath{}
				} else {
					yyv1190 := &yyv1187[yyj1187]
					yyv1190.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1187.End()
	}
	if yyc1187 {
		*v = yyv1187
	}

}

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

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

	yyv1193 := *v
	yyh1193, yyl1193 := z.DecSliceHelperStart()

	var yyrr1193, yyrl1193 int
	var yyc1193, yyrt1193 bool
	_, _, _ = yyc1193, yyrt1193, yyrl1193
	yyrr1193 = yyl1193

	if yyv1193 == nil {
		if yyrl1193, yyrt1193 = z.DecInferLen(yyl1193, z.DecBasicHandle().MaxInitLen, 24); yyrt1193 {
			yyrr1193 = yyrl1193
		}
		yyv1193 = make([]NodeUtilization, yyrl1193)
		yyc1193 = true
	}

	if yyl1193 == 0 {
		if len(yyv1193) != 0 {
			yyv1193 = yyv1193[:0]
			yyc1193 = true
		}
	} else if yyl1193 > 0 {

		if yyl1193 > cap(yyv1193) {
			yyrl1193, yyrt1193 = z.DecInferLen(yyl1193, z.DecBasicHandle().MaxInitLen, 24)
			yyv1193 = make([]NodeUtilization, yyrl1193)
			yyc1193 = true

			yyrr1193 = len(yyv1193)
		} else if yyl1193 != len(yyv1193) {
			yyv1193 = yyv1193[:yyl1193]
			yyc1193 = true
		}
		yyj1193 := 0
		for ; yyj1193 < yyrr1193; yyj1193++ {
			if r.TryDecodeAsNil() {
				yyv1193[yyj1193] = NodeUtilization{}
			} else {
				yyv1194 := &yyv1193[yyj1193]
				yyv1194.CodecDecodeSelf(d)
			}

		}
		if yyrt1193 {
			for ; yyj1193 < yyl1193; yyj1193++ {
				yyv1193 = append(yyv1193, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1193[yyj1193] = NodeUtilization{}
				} else {
					yyv1195 := &yyv1193[yyj1193]
					yyv1195.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1193 := 0; !r.CheckBreak(); yyj1193++ {
			if yyj1193 >= len(yyv1193) {
				yyv1193 = append(yyv1193, NodeUtilization{}) // var yyz1193 NodeUtilization
				yyc1193 = true
			}

			if yyj1193 < len(yyv1193) {
				if r.TryDecodeAsNil() {
					yyv1193[yyj1193] = NodeUtilization{}
				} else {
					yyv1196 := &yyv1193[yyj1193]
					yyv1196.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1193.End()
	}
	if yyc1193 {
		*v = yyv1193
	}

}

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

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

	yyv1199 := *v
	yyh1199, yyl1199 := z.DecSliceHelperStart()

	var yyrr1199, yyrl1199 int
	var yyc1199, yyrt1199 bool
	_, _, _ = yyc1199, yyrt1199, yyrl1199
	yyrr1199 = yyl1199

	if yyv1199 == nil {
		if yyrl1199, yyrt1199 = z.DecInferLen(yyl1199, z.DecBasicHandle().MaxInitLen, 232); yyrt1199 {
			yyrr1199 = yyrl1199
		}
		yyv1199 = make([]ClusterAutoscaler, yyrl1199)
		yyc1199 = true
	}

	if yyl1199 == 0 {
		if len(yyv1199) != 0 {
			yyv1199 = yyv1199[:0]
			yyc1199 = true
		}
	} else if yyl1199 > 0 {

		if yyl1199 > cap(yyv1199) {
			yyrl1199, yyrt1199 = z.DecInferLen(yyl1199, z.DecBasicHandle().MaxInitLen, 232)
			yyv1199 = make([]ClusterAutoscaler, yyrl1199)
			yyc1199 = true

			yyrr1199 = len(yyv1199)
		} else if yyl1199 != len(yyv1199) {
			yyv1199 = yyv1199[:yyl1199]
			yyc1199 = true
		}
		yyj1199 := 0
		for ; yyj1199 < yyrr1199; yyj1199++ {
			if r.TryDecodeAsNil() {
				yyv1199[yyj1199] = ClusterAutoscaler{}
			} else {
				yyv1200 := &yyv1199[yyj1199]
				yyv1200.CodecDecodeSelf(d)
			}

		}
		if yyrt1199 {
			for ; yyj1199 < yyl1199; yyj1199++ {
				yyv1199 = append(yyv1199, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1199[yyj1199] = ClusterAutoscaler{}
				} else {
					yyv1201 := &yyv1199[yyj1199]
					yyv1201.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1199 := 0; !r.CheckBreak(); yyj1199++ {
			if yyj1199 >= len(yyv1199) {
				yyv1199 = append(yyv1199, ClusterAutoscaler{}) // var yyz1199 ClusterAutoscaler
				yyc1199 = true
			}

			if yyj1199 < len(yyv1199) {
				if r.TryDecodeAsNil() {
					yyv1199[yyj1199] = ClusterAutoscaler{}
				} else {
					yyv1202 := &yyv1199[yyj1199]
					yyv1202.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1199.End()
	}
	if yyc1199 {
		*v = yyv1199
	}

}

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

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

	yyv1205 := *v
	yyh1205, yyl1205 := z.DecSliceHelperStart()

	var yyrr1205, yyrl1205 int
	var yyc1205, yyrt1205 bool
	_, _, _ = yyc1205, yyrt1205, yyrl1205
	yyrr1205 = yyl1205

	if yyv1205 == nil {
		if yyrl1205, yyrt1205 = z.DecInferLen(yyl1205, z.DecBasicHandle().MaxInitLen, 56); yyrt1205 {
			yyrr1205 = yyrl1205
		}
		yyv1205 = make([]PodSelectorRequirement, yyrl1205)
		yyc1205 = true
	}

	if yyl1205 == 0 {
		if len(yyv1205) != 0 {
			yyv1205 = yyv1205[:0]
			yyc1205 = true
		}
	} else if yyl1205 > 0 {

		if yyl1205 > cap(yyv1205) {
			yyrl1205, yyrt1205 = z.DecInferLen(yyl1205, z.DecBasicHandle().MaxInitLen, 56)
			yyv1205 = make([]PodSelectorRequirement, yyrl1205)
			yyc1205 = true

			yyrr1205 = len(yyv1205)
		} else if yyl1205 != len(yyv1205) {
			yyv1205 = yyv1205[:yyl1205]
			yyc1205 = true
		}
		yyj1205 := 0
		for ; yyj1205 < yyrr1205; yyj1205++ {
			if r.TryDecodeAsNil() {
				yyv1205[yyj1205] = PodSelectorRequirement{}
			} else {
				yyv1206 := &yyv1205[yyj1205]
				yyv1206.CodecDecodeSelf(d)
			}

		}
		if yyrt1205 {
			for ; yyj1205 < yyl1205; yyj1205++ {
				yyv1205 = append(yyv1205, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1205[yyj1205] = PodSelectorRequirement{}
				} else {
					yyv1207 := &yyv1205[yyj1205]
					yyv1207.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1205 := 0; !r.CheckBreak(); yyj1205++ {
			if yyj1205 >= len(yyv1205) {
				yyv1205 = append(yyv1205, PodSelectorRequirement{}) // var yyz1205 PodSelectorRequirement
				yyc1205 = true
			}

			if yyj1205 < len(yyv1205) {
				if r.TryDecodeAsNil() {
					yyv1205[yyj1205] = PodSelectorRequirement{}
				} else {
					yyv1208 := &yyv1205[yyj1205]
					yyv1208.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1205.End()
	}
	if yyc1205 {
		*v = yyv1205
	}

}
