types.generated.go

/*
Copyright 2015 The Kubernetes Authors All rights reserved.

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

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

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

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

package extensions

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg2_api "k8s.io/kubernetes/pkg/api"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	pkg6_intstr "k8s.io/kubernetes/pkg/util/intstr"
	"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_intstr.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_intstr.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_intstr.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_intstr.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_intstr.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] = x.Selector != nil
			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 {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq511[0] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(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
	yym514 := z.DecBinary()
	_ = yym514
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		if r.IsContainerType(codecSelferValueTypeMap1234) {
			yyl515 := r.ReadMapStart()
			if yyl515 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl515, d)
			}
		} else if r.IsContainerType(codecSelferValueTypeArray1234) {
			yyl515 := r.ReadArrayStart()
			if yyl515 == 0 {
				r.ReadEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl515, 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 yys516Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys516Slc
	var yyhl516 bool = l >= 0
	for yyj516 := 0; ; yyj516++ {
		if yyhl516 {
			if yyj516 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys516Slc = r.DecodeBytes(yys516Slc, true, true)
		yys516 := string(yys516Slc)
		switch yys516 {
		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() {
				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, yys516)
		} // end switch yys516
	} // end for yyj516
	if !yyhl516 {
		r.ReadEnd()
	}
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj519 int
	var yyb519 bool
	var yyhl519 bool = l >= 0
	yyj519++
	if yyhl519 {
		yyb519 = yyj519 > l
	} else {
		yyb519 = r.CheckBreak()
	}
	if yyb519 {
		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)
	}
	yyj519++
	if yyhl519 {
		yyb519 = yyj519 > l
	} else {
		yyb519 = r.CheckBreak()
	}
	if yyb519 {
		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 {
		yyj519++
		if yyhl519 {
			yyb519 = yyj519 > l
		} else {
			yyb519 = r.CheckBreak()
		}
		if yyb519 {
			break
		}
		z.DecStructFieldNotFound(yyj519-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 {
		yym522 := z.EncBinary()
		_ = yym522
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep523 := !z.EncBinary()
			yy2arr523 := z.EncBasicHandle().StructToArray
			var yyq523 [3]bool
			_, _, _ = yysep523, yyq523, yy2arr523
			const yyr523 bool = false
			if yyr523 || yy2arr523 {
				r.EncodeArrayStart(3)
			} else {
				var yynn523 int = 3
				for _, b := range yyq523 {
					if b {
						yynn523++
					}
				}
				r.EncodeMapStart(yynn523)
			}
			if yyr523 || yy2arr523 {
				yym525 := z.EncBinary()
				_ = yym525
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				yym526 := z.EncBinary()
				_ = yym526
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr523 || yy2arr523 {
				yym528 := z.EncBinary()
				_ = yym528
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				yym529 := z.EncBinary()
				_ = yym529
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr523 || yy2arr523 {
				yym531 := z.EncBinary()
				_ = yym531
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				yym532 := z.EncBinary()
				_ = yym532
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yysep523 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj539 int
	var yyb539 bool
	var yyhl539 bool = l >= 0
	yyj539++
	if yyhl539 {
		yyb539 = yyj539 > l
	} else {
		yyb539 = r.CheckBreak()
	}
	if yyb539 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj539++
	if yyhl539 {
		yyb539 = yyj539 > l
	} else {
		yyb539 = r.CheckBreak()
	}
	if yyb539 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj539++
	if yyhl539 {
		yyb539 = yyj539 > l
	} else {
		yyb539 = r.CheckBreak()
	}
	if yyb539 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj539++
		if yyhl539 {
			yyb539 = yyj539 > l
		} else {
			yyb539 = r.CheckBreak()
		}
		if yyb539 {
			break
		}
		z.DecStructFieldNotFound(yyj539-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 {
		yym543 := z.EncBinary()
		_ = yym543
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep544 := !z.EncBinary()
			yy2arr544 := z.EncBasicHandle().StructToArray
			var yyq544 [5]bool
			_, _, _ = yysep544, yyq544, yy2arr544
			const yyr544 bool = false
			yyq544[0] = x.Kind != ""
			yyq544[1] = x.APIVersion != ""
			yyq544[2] = true
			yyq544[3] = true
			yyq544[4] = true
			if yyr544 || yy2arr544 {
				r.EncodeArrayStart(5)
			} else {
				var yynn544 int = 0
				for _, b := range yyq544 {
					if b {
						yynn544++
					}
				}
				r.EncodeMapStart(yynn544)
			}
			if yyr544 || yy2arr544 {
				if yyq544[0] {
					yym546 := z.EncBinary()
					_ = yym546
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq544[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym547 := z.EncBinary()
					_ = yym547
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr544 || yy2arr544 {
				if yyq544[1] {
					yym549 := z.EncBinary()
					_ = yym549
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq544[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym550 := z.EncBinary()
					_ = yym550
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr544 || yy2arr544 {
				if yyq544[2] {
					yy552 := &x.ObjectMeta
					yy552.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq544[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy553 := &x.ObjectMeta
					yy553.CodecEncodeSelf(e)
				}
			}
			if yyr544 || yy2arr544 {
				if yyq544[3] {
					yy555 := &x.Spec
					yy555.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq544[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy556 := &x.Spec
					yy556.CodecEncodeSelf(e)
				}
			}
			if yyr544 || yy2arr544 {
				if yyq544[4] {
					yy558 := &x.Status
					yy558.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq544[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy559 := &x.Status
					yy559.CodecEncodeSelf(e)
				}
			}
			if yysep544 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj568 int
	var yyb568 bool
	var yyhl568 bool = l >= 0
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv571 := &x.ObjectMeta
		yyv571.CodecDecodeSelf(d)
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv572 := &x.Spec
		yyv572.CodecDecodeSelf(d)
	}
	yyj568++
	if yyhl568 {
		yyb568 = yyj568 > l
	} else {
		yyb568 = r.CheckBreak()
	}
	if yyb568 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv573 := &x.Status
		yyv573.CodecDecodeSelf(d)
	}
	for {
		yyj568++
		if yyhl568 {
			yyb568 = yyj568 > l
		} else {
			yyb568 = r.CheckBreak()
		}
		if yyb568 {
			break
		}
		z.DecStructFieldNotFound(yyj568-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 {
		yym574 := z.EncBinary()
		_ = yym574
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep575 := !z.EncBinary()
			yy2arr575 := z.EncBasicHandle().StructToArray
			var yyq575 [4]bool
			_, _, _ = yysep575, yyq575, yy2arr575
			const yyr575 bool = false
			yyq575[0] = x.Kind != ""
			yyq575[1] = x.APIVersion != ""
			yyq575[2] = true
			if yyr575 || yy2arr575 {
				r.EncodeArrayStart(4)
			} else {
				var yynn575 int = 1
				for _, b := range yyq575 {
					if b {
						yynn575++
					}
				}
				r.EncodeMapStart(yynn575)
			}
			if yyr575 || yy2arr575 {
				if yyq575[0] {
					yym577 := z.EncBinary()
					_ = yym577
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq575[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym578 := z.EncBinary()
					_ = yym578
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr575 || yy2arr575 {
				if yyq575[1] {
					yym580 := z.EncBinary()
					_ = yym580
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq575[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym581 := z.EncBinary()
					_ = yym581
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr575 || yy2arr575 {
				if yyq575[2] {
					yy583 := &x.ListMeta
					yym584 := z.EncBinary()
					_ = yym584
					if false {
					} else if z.HasExtensions() && z.EncExt(yy583) {
					} else {
						z.EncFallback(yy583)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq575[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy585 := &x.ListMeta
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else if z.HasExtensions() && z.EncExt(yy585) {
					} else {
						z.EncFallback(yy585)
					}
				}
			}
			if yyr575 || yy2arr575 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym588 := z.EncBinary()
					_ = yym588
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yysep575 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj599 int
	var yyb599 bool
	var yyhl599 bool = l >= 0
	yyj599++
	if yyhl599 {
		yyb599 = yyj599 > l
	} else {
		yyb599 = r.CheckBreak()
	}
	if yyb599 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj599++
	if yyhl599 {
		yyb599 = yyj599 > l
	} else {
		yyb599 = r.CheckBreak()
	}
	if yyb599 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj599++
	if yyhl599 {
		yyb599 = yyj599 > l
	} else {
		yyb599 = r.CheckBreak()
	}
	if yyb599 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv602 := &x.ListMeta
		yym603 := z.DecBinary()
		_ = yym603
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv602) {
		} else {
			z.DecFallback(yyv602, false)
		}
	}
	yyj599++
	if yyhl599 {
		yyb599 = yyj599 > l
	} else {
		yyb599 = r.CheckBreak()
	}
	if yyb599 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv604 := &x.Items
		yym605 := z.DecBinary()
		_ = yym605
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv604), d)
		}
	}
	for {
		yyj599++
		if yyhl599 {
			yyb599 = yyj599 > l
		} else {
			yyb599 = r.CheckBreak()
		}
		if yyb599 {
			break
		}
		z.DecStructFieldNotFound(yyj599-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 {
		yym606 := z.EncBinary()
		_ = yym606
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep607 := !z.EncBinary()
			yy2arr607 := z.EncBasicHandle().StructToArray
			var yyq607 [4]bool
			_, _, _ = yysep607, yyq607, yy2arr607
			const yyr607 bool = false
			yyq607[0] = x.Kind != ""
			yyq607[1] = x.APIVersion != ""
			yyq607[2] = true
			if yyr607 || yy2arr607 {
				r.EncodeArrayStart(4)
			} else {
				var yynn607 int = 1
				for _, b := range yyq607 {
					if b {
						yynn607++
					}
				}
				r.EncodeMapStart(yynn607)
			}
			if yyr607 || yy2arr607 {
				if yyq607[0] {
					yym609 := z.EncBinary()
					_ = yym609
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq607[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym610 := z.EncBinary()
					_ = yym610
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr607 || yy2arr607 {
				if yyq607[1] {
					yym612 := z.EncBinary()
					_ = yym612
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq607[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym613 := z.EncBinary()
					_ = yym613
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr607 || yy2arr607 {
				if yyq607[2] {
					yy615 := &x.ListMeta
					yym616 := z.EncBinary()
					_ = yym616
					if false {
					} else if z.HasExtensions() && z.EncExt(yy615) {
					} else {
						z.EncFallback(yy615)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq607[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy617 := &x.ListMeta
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else if z.HasExtensions() && z.EncExt(yy617) {
					} else {
						z.EncFallback(yy617)
					}
				}
			}
			if yyr607 || yy2arr607 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym620 := z.EncBinary()
					_ = yym620
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yysep607 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj631 int
	var yyb631 bool
	var yyhl631 bool = l >= 0
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv634 := &x.ListMeta
		yym635 := z.DecBinary()
		_ = yym635
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv634) {
		} else {
			z.DecFallback(yyv634, false)
		}
	}
	yyj631++
	if yyhl631 {
		yyb631 = yyj631 > l
	} else {
		yyb631 = r.CheckBreak()
	}
	if yyb631 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv636 := &x.Items
		yym637 := z.DecBinary()
		_ = yym637
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv636), d)
		}
	}
	for {
		yyj631++
		if yyhl631 {
			yyb631 = yyj631 > l
		} else {
			yyb631 = r.CheckBreak()
		}
		if yyb631 {
			break
		}
		z.DecStructFieldNotFound(yyj631-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 {
		yym638 := z.EncBinary()
		_ = yym638
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep639 := !z.EncBinary()
			yy2arr639 := z.EncBasicHandle().StructToArray
			var yyq639 [5]bool
			_, _, _ = yysep639, yyq639, yy2arr639
			const yyr639 bool = false
			yyq639[0] = x.Kind != ""
			yyq639[1] = x.APIVersion != ""
			yyq639[2] = true
			yyq639[3] = true
			yyq639[4] = true
			if yyr639 || yy2arr639 {
				r.EncodeArrayStart(5)
			} else {
				var yynn639 int = 0
				for _, b := range yyq639 {
					if b {
						yynn639++
					}
				}
				r.EncodeMapStart(yynn639)
			}
			if yyr639 || yy2arr639 {
				if yyq639[0] {
					yym641 := z.EncBinary()
					_ = yym641
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq639[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym642 := z.EncBinary()
					_ = yym642
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr639 || yy2arr639 {
				if yyq639[1] {
					yym644 := z.EncBinary()
					_ = yym644
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq639[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym645 := z.EncBinary()
					_ = yym645
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr639 || yy2arr639 {
				if yyq639[2] {
					yy647 := &x.ObjectMeta
					yy647.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq639[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy648 := &x.ObjectMeta
					yy648.CodecEncodeSelf(e)
				}
			}
			if yyr639 || yy2arr639 {
				if yyq639[3] {
					yy650 := &x.Spec
					yy650.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq639[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy651 := &x.Spec
					yy651.CodecEncodeSelf(e)
				}
			}
			if yyr639 || yy2arr639 {
				if yyq639[4] {
					yy653 := &x.Status
					yy653.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq639[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy654 := &x.Status
					yy654.CodecEncodeSelf(e)
				}
			}
			if yysep639 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj663 int
	var yyb663 bool
	var yyhl663 bool = l >= 0
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv666 := &x.ObjectMeta
		yyv666.CodecDecodeSelf(d)
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv667 := &x.Spec
		yyv667.CodecDecodeSelf(d)
	}
	yyj663++
	if yyhl663 {
		yyb663 = yyj663 > l
	} else {
		yyb663 = r.CheckBreak()
	}
	if yyb663 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv668 := &x.Status
		yyv668.CodecDecodeSelf(d)
	}
	for {
		yyj663++
		if yyhl663 {
			yyb663 = yyj663 > l
		} else {
			yyb663 = r.CheckBreak()
		}
		if yyb663 {
			break
		}
		z.DecStructFieldNotFound(yyj663-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 {
		yym669 := z.EncBinary()
		_ = yym669
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep670 := !z.EncBinary()
			yy2arr670 := z.EncBasicHandle().StructToArray
			var yyq670 [4]bool
			_, _, _ = yysep670, yyq670, yy2arr670
			const yyr670 bool = false
			yyq670[0] = x.Kind != ""
			yyq670[1] = x.APIVersion != ""
			yyq670[2] = true
			if yyr670 || yy2arr670 {
				r.EncodeArrayStart(4)
			} else {
				var yynn670 int = 1
				for _, b := range yyq670 {
					if b {
						yynn670++
					}
				}
				r.EncodeMapStart(yynn670)
			}
			if yyr670 || yy2arr670 {
				if yyq670[0] {
					yym672 := z.EncBinary()
					_ = yym672
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq670[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym673 := z.EncBinary()
					_ = yym673
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr670 || yy2arr670 {
				if yyq670[1] {
					yym675 := z.EncBinary()
					_ = yym675
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq670[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym676 := z.EncBinary()
					_ = yym676
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr670 || yy2arr670 {
				if yyq670[2] {
					yy678 := &x.ListMeta
					yym679 := z.EncBinary()
					_ = yym679
					if false {
					} else if z.HasExtensions() && z.EncExt(yy678) {
					} else {
						z.EncFallback(yy678)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq670[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy680 := &x.ListMeta
					yym681 := z.EncBinary()
					_ = yym681
					if false {
					} else if z.HasExtensions() && z.EncExt(yy680) {
					} else {
						z.EncFallback(yy680)
					}
				}
			}
			if yyr670 || yy2arr670 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym683 := z.EncBinary()
					_ = yym683
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym684 := z.EncBinary()
					_ = yym684
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yysep670 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj694 int
	var yyb694 bool
	var yyhl694 bool = l >= 0
	yyj694++
	if yyhl694 {
		yyb694 = yyj694 > l
	} else {
		yyb694 = r.CheckBreak()
	}
	if yyb694 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj694++
	if yyhl694 {
		yyb694 = yyj694 > l
	} else {
		yyb694 = r.CheckBreak()
	}
	if yyb694 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj694++
	if yyhl694 {
		yyb694 = yyj694 > l
	} else {
		yyb694 = r.CheckBreak()
	}
	if yyb694 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv697 := &x.ListMeta
		yym698 := z.DecBinary()
		_ = yym698
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv697) {
		} else {
			z.DecFallback(yyv697, false)
		}
	}
	yyj694++
	if yyhl694 {
		yyb694 = yyj694 > l
	} else {
		yyb694 = r.CheckBreak()
	}
	if yyb694 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv699 := &x.Items
		yym700 := z.DecBinary()
		_ = yym700
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv699), d)
		}
	}
	for {
		yyj694++
		if yyhl694 {
			yyb694 = yyj694 > l
		} else {
			yyb694 = r.CheckBreak()
		}
		if yyb694 {
			break
		}
		z.DecStructFieldNotFound(yyj694-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 {
		yym701 := z.EncBinary()
		_ = yym701
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep702 := !z.EncBinary()
			yy2arr702 := z.EncBasicHandle().StructToArray
			var yyq702 [4]bool
			_, _, _ = yysep702, yyq702, yy2arr702
			const yyr702 bool = false
			yyq702[0] = x.Parallelism != nil
			yyq702[1] = x.Completions != nil
			yyq702[2] = x.Selector != nil
			if yyr702 || yy2arr702 {
				r.EncodeArrayStart(4)
			} else {
				var yynn702 int = 1
				for _, b := range yyq702 {
					if b {
						yynn702++
					}
				}
				r.EncodeMapStart(yynn702)
			}
			if yyr702 || yy2arr702 {
				if yyq702[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy704 := *x.Parallelism
						yym705 := z.EncBinary()
						_ = yym705
						if false {
						} else {
							r.EncodeInt(int64(yy704))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq702[0] {
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy706 := *x.Parallelism
						yym707 := z.EncBinary()
						_ = yym707
						if false {
						} else {
							r.EncodeInt(int64(yy706))
						}
					}
				}
			}
			if yyr702 || yy2arr702 {
				if yyq702[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy709 := *x.Completions
						yym710 := z.EncBinary()
						_ = yym710
						if false {
						} else {
							r.EncodeInt(int64(yy709))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq702[1] {
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy711 := *x.Completions
						yym712 := z.EncBinary()
						_ = yym712
						if false {
						} else {
							r.EncodeInt(int64(yy711))
						}
					}
				}
			}
			if yyr702 || yy2arr702 {
				if yyq702[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq702[2] {
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr702 || yy2arr702 {
				yy715 := &x.Template
				yy715.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				yy716 := &x.Template
				yy716.CodecEncodeSelf(e)
			}
			if yysep702 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj726 int
	var yyb726 bool
	var yyhl726 bool = l >= 0
	yyj726++
	if yyhl726 {
		yyb726 = yyj726 > l
	} else {
		yyb726 = r.CheckBreak()
	}
	if yyb726 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int)
		}
		yym728 := z.DecBinary()
		_ = yym728
		if false {
		} else {
			*((*int)(x.Parallelism)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj726++
	if yyhl726 {
		yyb726 = yyj726 > l
	} else {
		yyb726 = r.CheckBreak()
	}
	if yyb726 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int)
		}
		yym730 := z.DecBinary()
		_ = yym730
		if false {
		} else {
			*((*int)(x.Completions)) = int(r.DecodeInt(codecSelferBitsize1234))
		}
	}
	yyj726++
	if yyhl726 {
		yyb726 = yyj726 > l
	} else {
		yyb726 = r.CheckBreak()
	}
	if yyb726 {
		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)
	}
	yyj726++
	if yyhl726 {
		yyb726 = yyj726 > l
	} else {
		yyb726 = r.CheckBreak()
	}
	if yyb726 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv732 := &x.Template
		yyv732.CodecDecodeSelf(d)
	}
	for {
		yyj726++
		if yyhl726 {
			yyb726 = yyj726 > l
		} else {
			yyb726 = r.CheckBreak()
		}
		if yyb726 {
			break
		}
		z.DecStructFieldNotFound(yyj726-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 {
		yym733 := z.EncBinary()
		_ = yym733
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep734 := !z.EncBinary()
			yy2arr734 := z.EncBasicHandle().StructToArray
			var yyq734 [6]bool
			_, _, _ = yysep734, yyq734, yy2arr734
			const yyr734 bool = false
			yyq734[0] = len(x.Conditions) != 0
			yyq734[1] = x.StartTime != nil
			yyq734[2] = x.CompletionTime != nil
			yyq734[3] = x.Active != 0
			yyq734[4] = x.Succeeded != 0
			yyq734[5] = x.Failed != 0
			if yyr734 || yy2arr734 {
				r.EncodeArrayStart(6)
			} else {
				var yynn734 int = 0
				for _, b := range yyq734 {
					if b {
						yynn734++
					}
				}
				r.EncodeMapStart(yynn734)
			}
			if yyr734 || yy2arr734 {
				if yyq734[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym736 := z.EncBinary()
						_ = yym736
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq734[0] {
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym737 := z.EncBinary()
						_ = yym737
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr734 || yy2arr734 {
				if yyq734[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym739 := z.EncBinary()
						_ = yym739
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym739 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym739 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq734[1] {
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym740 := z.EncBinary()
						_ = yym740
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym740 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym740 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr734 || yy2arr734 {
				if yyq734[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym742 := z.EncBinary()
						_ = yym742
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym742 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym742 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq734[2] {
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym743 := z.EncBinary()
						_ = yym743
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym743 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym743 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr734 || yy2arr734 {
				if yyq734[3] {
					yym745 := z.EncBinary()
					_ = yym745
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq734[3] {
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					yym746 := z.EncBinary()
					_ = yym746
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr734 || yy2arr734 {
				if yyq734[4] {
					yym748 := z.EncBinary()
					_ = yym748
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq734[4] {
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					yym749 := z.EncBinary()
					_ = yym749
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr734 || yy2arr734 {
				if yyq734[5] {
					yym751 := z.EncBinary()
					_ = yym751
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq734[5] {
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					yym752 := z.EncBinary()
					_ = yym752
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yysep734 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym775 := z.EncBinary()
	_ = yym775
	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
	yym776 := z.DecBinary()
	_ = yym776
	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 {
		yym777 := z.EncBinary()
		_ = yym777
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep778 := !z.EncBinary()
			yy2arr778 := z.EncBasicHandle().StructToArray
			var yyq778 [6]bool
			_, _, _ = yysep778, yyq778, yy2arr778
			const yyr778 bool = false
			yyq778[2] = true
			yyq778[3] = true
			yyq778[4] = x.Reason != ""
			yyq778[5] = x.Message != ""
			if yyr778 || yy2arr778 {
				r.EncodeArrayStart(6)
			} else {
				var yynn778 int = 2
				for _, b := range yyq778 {
					if b {
						yynn778++
					}
				}
				r.EncodeMapStart(yynn778)
			}
			if yyr778 || yy2arr778 {
				x.Type.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				x.Type.CodecEncodeSelf(e)
			}
			if yyr778 || yy2arr778 {
				yym781 := z.EncBinary()
				_ = yym781
				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"))
				yym782 := z.EncBinary()
				_ = yym782
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr778 || yy2arr778 {
				if yyq778[2] {
					yy784 := &x.LastProbeTime
					yym785 := z.EncBinary()
					_ = yym785
					if false {
					} else if z.HasExtensions() && z.EncExt(yy784) {
					} else if yym785 {
						z.EncBinaryMarshal(yy784)
					} else if !yym785 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy784)
					} else {
						z.EncFallback(yy784)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq778[2] {
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					yy786 := &x.LastProbeTime
					yym787 := z.EncBinary()
					_ = yym787
					if false {
					} else if z.HasExtensions() && z.EncExt(yy786) {
					} else if yym787 {
						z.EncBinaryMarshal(yy786)
					} else if !yym787 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy786)
					} else {
						z.EncFallback(yy786)
					}
				}
			}
			if yyr778 || yy2arr778 {
				if yyq778[3] {
					yy789 := &x.LastTransitionTime
					yym790 := z.EncBinary()
					_ = yym790
					if false {
					} else if z.HasExtensions() && z.EncExt(yy789) {
					} else if yym790 {
						z.EncBinaryMarshal(yy789)
					} else if !yym790 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy789)
					} else {
						z.EncFallback(yy789)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq778[3] {
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					yy791 := &x.LastTransitionTime
					yym792 := z.EncBinary()
					_ = yym792
					if false {
					} else if z.HasExtensions() && z.EncExt(yy791) {
					} else if yym792 {
						z.EncBinaryMarshal(yy791)
					} else if !yym792 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy791)
					} else {
						z.EncFallback(yy791)
					}
				}
			}
			if yyr778 || yy2arr778 {
				if yyq778[4] {
					yym794 := z.EncBinary()
					_ = yym794
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq778[4] {
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					yym795 := z.EncBinary()
					_ = yym795
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr778 || yy2arr778 {
				if yyq778[5] {
					yym797 := z.EncBinary()
					_ = yym797
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq778[5] {
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					yym798 := z.EncBinary()
					_ = yym798
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yysep778 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj810 int
	var yyb810 bool
	var yyhl810 bool = l >= 0
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_api.ConditionStatus(r.DecodeString())
	}
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv813 := &x.LastProbeTime
		yym814 := z.DecBinary()
		_ = yym814
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv813) {
		} else if yym814 {
			z.DecBinaryUnmarshal(yyv813)
		} else if !yym814 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv813)
		} else {
			z.DecFallback(yyv813, false)
		}
	}
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv815 := &x.LastTransitionTime
		yym816 := z.DecBinary()
		_ = yym816
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv815) {
		} else if yym816 {
			z.DecBinaryUnmarshal(yyv815)
		} else if !yym816 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv815)
		} else {
			z.DecFallback(yyv815, false)
		}
	}
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj810++
	if yyhl810 {
		yyb810 = yyj810 > l
	} else {
		yyb810 = r.CheckBreak()
	}
	if yyb810 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj810++
		if yyhl810 {
			yyb810 = yyj810 > l
		} else {
			yyb810 = r.CheckBreak()
		}
		if yyb810 {
			break
		}
		z.DecStructFieldNotFound(yyj810-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 {
		yym819 := z.EncBinary()
		_ = yym819
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep820 := !z.EncBinary()
			yy2arr820 := z.EncBasicHandle().StructToArray
			var yyq820 [5]bool
			_, _, _ = yysep820, yyq820, yy2arr820
			const yyr820 bool = false
			yyq820[0] = x.Kind != ""
			yyq820[1] = x.APIVersion != ""
			yyq820[2] = true
			yyq820[3] = true
			yyq820[4] = true
			if yyr820 || yy2arr820 {
				r.EncodeArrayStart(5)
			} else {
				var yynn820 int = 0
				for _, b := range yyq820 {
					if b {
						yynn820++
					}
				}
				r.EncodeMapStart(yynn820)
			}
			if yyr820 || yy2arr820 {
				if yyq820[0] {
					yym822 := z.EncBinary()
					_ = yym822
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq820[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym823 := z.EncBinary()
					_ = yym823
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr820 || yy2arr820 {
				if yyq820[1] {
					yym825 := z.EncBinary()
					_ = yym825
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq820[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym826 := z.EncBinary()
					_ = yym826
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr820 || yy2arr820 {
				if yyq820[2] {
					yy828 := &x.ObjectMeta
					yy828.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq820[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy829 := &x.ObjectMeta
					yy829.CodecEncodeSelf(e)
				}
			}
			if yyr820 || yy2arr820 {
				if yyq820[3] {
					yy831 := &x.Spec
					yy831.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq820[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy832 := &x.Spec
					yy832.CodecEncodeSelf(e)
				}
			}
			if yyr820 || yy2arr820 {
				if yyq820[4] {
					yy834 := &x.Status
					yy834.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq820[4] {
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					yy835 := &x.Status
					yy835.CodecEncodeSelf(e)
				}
			}
			if yysep820 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj844 int
	var yyb844 bool
	var yyhl844 bool = l >= 0
	yyj844++
	if yyhl844 {
		yyb844 = yyj844 > l
	} else {
		yyb844 = r.CheckBreak()
	}
	if yyb844 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj844++
	if yyhl844 {
		yyb844 = yyj844 > l
	} else {
		yyb844 = r.CheckBreak()
	}
	if yyb844 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj844++
	if yyhl844 {
		yyb844 = yyj844 > l
	} else {
		yyb844 = r.CheckBreak()
	}
	if yyb844 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv847 := &x.ObjectMeta
		yyv847.CodecDecodeSelf(d)
	}
	yyj844++
	if yyhl844 {
		yyb844 = yyj844 > l
	} else {
		yyb844 = r.CheckBreak()
	}
	if yyb844 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv848 := &x.Spec
		yyv848.CodecDecodeSelf(d)
	}
	yyj844++
	if yyhl844 {
		yyb844 = yyj844 > l
	} else {
		yyb844 = r.CheckBreak()
	}
	if yyb844 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv849 := &x.Status
		yyv849.CodecDecodeSelf(d)
	}
	for {
		yyj844++
		if yyhl844 {
			yyb844 = yyj844 > l
		} else {
			yyb844 = r.CheckBreak()
		}
		if yyb844 {
			break
		}
		z.DecStructFieldNotFound(yyj844-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 {
		yym850 := z.EncBinary()
		_ = yym850
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep851 := !z.EncBinary()
			yy2arr851 := z.EncBasicHandle().StructToArray
			var yyq851 [4]bool
			_, _, _ = yysep851, yyq851, yy2arr851
			const yyr851 bool = false
			yyq851[0] = x.Kind != ""
			yyq851[1] = x.APIVersion != ""
			yyq851[2] = true
			if yyr851 || yy2arr851 {
				r.EncodeArrayStart(4)
			} else {
				var yynn851 int = 1
				for _, b := range yyq851 {
					if b {
						yynn851++
					}
				}
				r.EncodeMapStart(yynn851)
			}
			if yyr851 || yy2arr851 {
				if yyq851[0] {
					yym853 := z.EncBinary()
					_ = yym853
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq851[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym854 := z.EncBinary()
					_ = yym854
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr851 || yy2arr851 {
				if yyq851[1] {
					yym856 := z.EncBinary()
					_ = yym856
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq851[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym857 := z.EncBinary()
					_ = yym857
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr851 || yy2arr851 {
				if yyq851[2] {
					yy859 := &x.ListMeta
					yym860 := z.EncBinary()
					_ = yym860
					if false {
					} else if z.HasExtensions() && z.EncExt(yy859) {
					} else {
						z.EncFallback(yy859)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq851[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy861 := &x.ListMeta
					yym862 := z.EncBinary()
					_ = yym862
					if false {
					} else if z.HasExtensions() && z.EncExt(yy861) {
					} else {
						z.EncFallback(yy861)
					}
				}
			}
			if yyr851 || yy2arr851 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym864 := z.EncBinary()
					_ = yym864
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym865 := z.EncBinary()
					_ = yym865
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yysep851 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj875 int
	var yyb875 bool
	var yyhl875 bool = l >= 0
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv878 := &x.ListMeta
		yym879 := z.DecBinary()
		_ = yym879
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv878) {
		} else {
			z.DecFallback(yyv878, false)
		}
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv880 := &x.Items
		yym881 := z.DecBinary()
		_ = yym881
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv880), d)
		}
	}
	for {
		yyj875++
		if yyhl875 {
			yyb875 = yyj875 > l
		} else {
			yyb875 = r.CheckBreak()
		}
		if yyb875 {
			break
		}
		z.DecStructFieldNotFound(yyj875-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 {
		yym882 := z.EncBinary()
		_ = yym882
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep883 := !z.EncBinary()
			yy2arr883 := z.EncBasicHandle().StructToArray
			var yyq883 [2]bool
			_, _, _ = yysep883, yyq883, yy2arr883
			const yyr883 bool = false
			yyq883[0] = x.Backend != nil
			yyq883[1] = len(x.Rules) != 0
			if yyr883 || yy2arr883 {
				r.EncodeArrayStart(2)
			} else {
				var yynn883 int = 0
				for _, b := range yyq883 {
					if b {
						yynn883++
					}
				}
				r.EncodeMapStart(yynn883)
			}
			if yyr883 || yy2arr883 {
				if yyq883[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq883[0] {
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr883 || yy2arr883 {
				if yyq883[1] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym886 := z.EncBinary()
						_ = yym886
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq883[1] {
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym887 := z.EncBinary()
						_ = yym887
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yysep883 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj894 int
	var yyb894 bool
	var yyhl894 bool = l >= 0
	yyj894++
	if yyhl894 {
		yyb894 = yyj894 > l
	} else {
		yyb894 = r.CheckBreak()
	}
	if yyb894 {
		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)
	}
	yyj894++
	if yyhl894 {
		yyb894 = yyj894 > l
	} else {
		yyb894 = r.CheckBreak()
	}
	if yyb894 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv896 := &x.Rules
		yym897 := z.DecBinary()
		_ = yym897
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv896), d)
		}
	}
	for {
		yyj894++
		if yyhl894 {
			yyb894 = yyj894 > l
		} else {
			yyb894 = r.CheckBreak()
		}
		if yyb894 {
			break
		}
		z.DecStructFieldNotFound(yyj894-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 {
		yym898 := z.EncBinary()
		_ = yym898
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep899 := !z.EncBinary()
			yy2arr899 := z.EncBasicHandle().StructToArray
			var yyq899 [1]bool
			_, _, _ = yysep899, yyq899, yy2arr899
			const yyr899 bool = false
			yyq899[0] = true
			if yyr899 || yy2arr899 {
				r.EncodeArrayStart(1)
			} else {
				var yynn899 int = 0
				for _, b := range yyq899 {
					if b {
						yynn899++
					}
				}
				r.EncodeMapStart(yynn899)
			}
			if yyr899 || yy2arr899 {
				if yyq899[0] {
					yy901 := &x.LoadBalancer
					yy901.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq899[0] {
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					yy902 := &x.LoadBalancer
					yy902.CodecEncodeSelf(e)
				}
			}
			if yysep899 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj907 int
	var yyb907 bool
	var yyhl907 bool = l >= 0
	yyj907++
	if yyhl907 {
		yyb907 = yyj907 > l
	} else {
		yyb907 = r.CheckBreak()
	}
	if yyb907 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv908 := &x.LoadBalancer
		yyv908.CodecDecodeSelf(d)
	}
	for {
		yyj907++
		if yyhl907 {
			yyb907 = yyj907 > l
		} else {
			yyb907 = r.CheckBreak()
		}
		if yyb907 {
			break
		}
		z.DecStructFieldNotFound(yyj907-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 {
		yym909 := z.EncBinary()
		_ = yym909
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep910 := !z.EncBinary()
			yy2arr910 := z.EncBasicHandle().StructToArray
			var yyq910 [2]bool
			_, _, _ = yysep910, yyq910, yy2arr910
			const yyr910 bool = false
			yyq910[0] = x.Host != ""
			yyq910[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			if yyr910 || yy2arr910 {
				r.EncodeArrayStart(2)
			} else {
				var yynn910 int = 0
				for _, b := range yyq910 {
					if b {
						yynn910++
					}
				}
				r.EncodeMapStart(yynn910)
			}
			if yyr910 || yy2arr910 {
				if yyq910[0] {
					yym912 := z.EncBinary()
					_ = yym912
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq910[0] {
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					yym913 := z.EncBinary()
					_ = yym913
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn914 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn914 = true
				goto LABEL914
			}
		LABEL914:
			if yyr910 || yy2arr910 {
				if yyn914 {
					r.EncodeNil()
				} else {
					if yyq910[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq910[1] {
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					if yyn914 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yysep910 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

func (x *IngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys928Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys928Slc
	var yyhl928 bool = l >= 0
	for yyj928 := 0; ; yyj928++ {
		if yyhl928 {
			if yyj928 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys928Slc = r.DecodeBytes(yys928Slc, true, true)
		yys928 := string(yys928Slc)
		switch yys928 {
		case "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, yys928)
		} // end switch yys928
	} // end for yyj928
	if !yyhl928 {
		r.ReadEnd()
	}
}

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj930 int
	var yyb930 bool
	var yyhl930 bool = l >= 0
	yyj930++
	if yyhl930 {
		yyb930 = yyj930 > l
	} else {
		yyb930 = r.CheckBreak()
	}
	if yyb930 {
		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 {
		yyj930++
		if yyhl930 {
			yyb930 = yyj930 > l
		} else {
			yyb930 = r.CheckBreak()
		}
		if yyb930 {
			break
		}
		z.DecStructFieldNotFound(yyj930-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 {
		yym932 := z.EncBinary()
		_ = yym932
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep933 := !z.EncBinary()
			yy2arr933 := z.EncBasicHandle().StructToArray
			var yyq933 [1]bool
			_, _, _ = yysep933, yyq933, yy2arr933
			const yyr933 bool = false
			if yyr933 || yy2arr933 {
				r.EncodeArrayStart(1)
			} else {
				var yynn933 int = 1
				for _, b := range yyq933 {
					if b {
						yynn933++
					}
				}
				r.EncodeMapStart(yynn933)
			}
			if yyr933 || yy2arr933 {
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym935 := z.EncBinary()
					_ = yym935
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym936 := z.EncBinary()
					_ = yym936
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yysep933 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressRuleValue) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys939Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys939Slc
	var yyhl939 bool = l >= 0
	for yyj939 := 0; ; yyj939++ {
		if yyhl939 {
			if yyj939 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		yys939Slc = r.DecodeBytes(yys939Slc, true, true)
		yys939 := string(yys939Slc)
		switch yys939 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv940 := &x.Paths
				yym941 := z.DecBinary()
				_ = yym941
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv940), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys939)
		} // end switch yys939
	} // end for yyj939
	if !yyhl939 {
		r.ReadEnd()
	}
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj942 int
	var yyb942 bool
	var yyhl942 bool = l >= 0
	yyj942++
	if yyhl942 {
		yyb942 = yyj942 > l
	} else {
		yyb942 = r.CheckBreak()
	}
	if yyb942 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv943 := &x.Paths
		yym944 := z.DecBinary()
		_ = yym944
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv943), d)
		}
	}
	for {
		yyj942++
		if yyhl942 {
			yyb942 = yyj942 > l
		} else {
			yyb942 = r.CheckBreak()
		}
		if yyb942 {
			break
		}
		z.DecStructFieldNotFound(yyj942-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 {
		yym945 := z.EncBinary()
		_ = yym945
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep946 := !z.EncBinary()
			yy2arr946 := z.EncBasicHandle().StructToArray
			var yyq946 [2]bool
			_, _, _ = yysep946, yyq946, yy2arr946
			const yyr946 bool = false
			yyq946[0] = x.Path != ""
			if yyr946 || yy2arr946 {
				r.EncodeArrayStart(2)
			} else {
				var yynn946 int = 1
				for _, b := range yyq946 {
					if b {
						yynn946++
					}
				}
				r.EncodeMapStart(yynn946)
			}
			if yyr946 || yy2arr946 {
				if yyq946[0] {
					yym948 := z.EncBinary()
					_ = yym948
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq946[0] {
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					yym949 := z.EncBinary()
					_ = yym949
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr946 || yy2arr946 {
				yy951 := &x.Backend
				yy951.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				yy952 := &x.Backend
				yy952.CodecEncodeSelf(e)
			}
			if yysep946 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj958 int
	var yyb958 bool
	var yyhl958 bool = l >= 0
	yyj958++
	if yyhl958 {
		yyb958 = yyj958 > l
	} else {
		yyb958 = r.CheckBreak()
	}
	if yyb958 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj958++
	if yyhl958 {
		yyb958 = yyj958 > l
	} else {
		yyb958 = r.CheckBreak()
	}
	if yyb958 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv960 := &x.Backend
		yyv960.CodecDecodeSelf(d)
	}
	for {
		yyj958++
		if yyhl958 {
			yyb958 = yyj958 > l
		} else {
			yyb958 = r.CheckBreak()
		}
		if yyb958 {
			break
		}
		z.DecStructFieldNotFound(yyj958-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 {
		yym961 := z.EncBinary()
		_ = yym961
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep962 := !z.EncBinary()
			yy2arr962 := z.EncBasicHandle().StructToArray
			var yyq962 [2]bool
			_, _, _ = yysep962, yyq962, yy2arr962
			const yyr962 bool = false
			if yyr962 || yy2arr962 {
				r.EncodeArrayStart(2)
			} else {
				var yynn962 int = 2
				for _, b := range yyq962 {
					if b {
						yynn962++
					}
				}
				r.EncodeMapStart(yynn962)
			}
			if yyr962 || yy2arr962 {
				yym964 := z.EncBinary()
				_ = yym964
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				yym965 := z.EncBinary()
				_ = yym965
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr962 || yy2arr962 {
				yy967 := &x.ServicePort
				yym968 := z.EncBinary()
				_ = yym968
				if false {
				} else if z.HasExtensions() && z.EncExt(yy967) {
				} else if !yym968 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy967)
				} else {
					z.EncFallback(yy967)
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				yy969 := &x.ServicePort
				yym970 := z.EncBinary()
				_ = yym970
				if false {
				} else if z.HasExtensions() && z.EncExt(yy969) {
				} else if !yym970 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy969)
				} else {
					z.EncFallback(yy969)
				}
			}
			if yysep962 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

func (x NodeResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym981 := z.EncBinary()
	_ = yym981
	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
	yym982 := z.DecBinary()
	_ = yym982
	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 {
		yym983 := z.EncBinary()
		_ = yym983
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep984 := !z.EncBinary()
			yy2arr984 := z.EncBasicHandle().StructToArray
			var yyq984 [2]bool
			_, _, _ = yysep984, yyq984, yy2arr984
			const yyr984 bool = false
			if yyr984 || yy2arr984 {
				r.EncodeArrayStart(2)
			} else {
				var yynn984 int = 2
				for _, b := range yyq984 {
					if b {
						yynn984++
					}
				}
				r.EncodeMapStart(yynn984)
			}
			if yyr984 || yy2arr984 {
				x.Resource.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("resource"))
				x.Resource.CodecEncodeSelf(e)
			}
			if yyr984 || yy2arr984 {
				yym987 := z.EncBinary()
				_ = yym987
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				yym988 := z.EncBinary()
				_ = yym988
				if false {
				} else {
					r.EncodeFloat64(float64(x.Value))
				}
			}
			if yysep984 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *NodeUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj994 int
	var yyb994 bool
	var yyhl994 bool = l >= 0
	yyj994++
	if yyhl994 {
		yyb994 = yyj994 > l
	} else {
		yyb994 = r.CheckBreak()
	}
	if yyb994 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = NodeResource(r.DecodeString())
	}
	yyj994++
	if yyhl994 {
		yyb994 = yyj994 > l
	} else {
		yyb994 = r.CheckBreak()
	}
	if yyb994 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Value = 0
	} else {
		x.Value = float64(r.DecodeFloat(false))
	}
	for {
		yyj994++
		if yyhl994 {
			yyb994 = yyj994 > l
		} else {
			yyb994 = r.CheckBreak()
		}
		if yyb994 {
			break
		}
		z.DecStructFieldNotFound(yyj994-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 {
		yym997 := z.EncBinary()
		_ = yym997
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep998 := !z.EncBinary()
			yy2arr998 := z.EncBasicHandle().StructToArray
			var yyq998 [3]bool
			_, _, _ = yysep998, yyq998, yy2arr998
			const yyr998 bool = false
			if yyr998 || yy2arr998 {
				r.EncodeArrayStart(3)
			} else {
				var yynn998 int = 3
				for _, b := range yyq998 {
					if b {
						yynn998++
					}
				}
				r.EncodeMapStart(yynn998)
			}
			if yyr998 || yy2arr998 {
				yym1000 := z.EncBinary()
				_ = yym1000
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("minNodes"))
				yym1001 := z.EncBinary()
				_ = yym1001
				if false {
				} else {
					r.EncodeInt(int64(x.MinNodes))
				}
			}
			if yyr998 || yy2arr998 {
				yym1003 := z.EncBinary()
				_ = yym1003
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("maxNodes"))
				yym1004 := z.EncBinary()
				_ = yym1004
				if false {
				} else {
					r.EncodeInt(int64(x.MaxNodes))
				}
			}
			if yyr998 || yy2arr998 {
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1006 := z.EncBinary()
					_ = yym1006
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("target"))
				if x.TargetUtilization == nil {
					r.EncodeNil()
				} else {
					yym1007 := z.EncBinary()
					_ = yym1007
					if false {
					} else {
						h.encSliceNodeUtilization(([]NodeUtilization)(x.TargetUtilization), e)
					}
				}
			}
			if yysep998 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1015 int
	var yyb1015 bool
	var yyhl1015 bool = l >= 0
	yyj1015++
	if yyhl1015 {
		yyb1015 = yyj1015 > l
	} else {
		yyb1015 = r.CheckBreak()
	}
	if yyb1015 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MinNodes = 0
	} else {
		x.MinNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1015++
	if yyhl1015 {
		yyb1015 = yyj1015 > l
	} else {
		yyb1015 = r.CheckBreak()
	}
	if yyb1015 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MaxNodes = 0
	} else {
		x.MaxNodes = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1015++
	if yyhl1015 {
		yyb1015 = yyj1015 > l
	} else {
		yyb1015 = r.CheckBreak()
	}
	if yyb1015 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.TargetUtilization = nil
	} else {
		yyv1018 := &x.TargetUtilization
		yym1019 := z.DecBinary()
		_ = yym1019
		if false {
		} else {
			h.decSliceNodeUtilization((*[]NodeUtilization)(yyv1018), d)
		}
	}
	for {
		yyj1015++
		if yyhl1015 {
			yyb1015 = yyj1015 > l
		} else {
			yyb1015 = r.CheckBreak()
		}
		if yyb1015 {
			break
		}
		z.DecStructFieldNotFound(yyj1015-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 {
		yym1020 := z.EncBinary()
		_ = yym1020
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1021 := !z.EncBinary()
			yy2arr1021 := z.EncBasicHandle().StructToArray
			var yyq1021 [4]bool
			_, _, _ = yysep1021, yyq1021, yy2arr1021
			const yyr1021 bool = false
			yyq1021[0] = x.Kind != ""
			yyq1021[1] = x.APIVersion != ""
			yyq1021[2] = true
			yyq1021[3] = true
			if yyr1021 || yy2arr1021 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1021 int = 0
				for _, b := range yyq1021 {
					if b {
						yynn1021++
					}
				}
				r.EncodeMapStart(yynn1021)
			}
			if yyr1021 || yy2arr1021 {
				if yyq1021[0] {
					yym1023 := z.EncBinary()
					_ = yym1023
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1021[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1024 := z.EncBinary()
					_ = yym1024
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1021 || yy2arr1021 {
				if yyq1021[1] {
					yym1026 := z.EncBinary()
					_ = yym1026
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1021[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1027 := z.EncBinary()
					_ = yym1027
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1021 || yy2arr1021 {
				if yyq1021[2] {
					yy1029 := &x.ObjectMeta
					yy1029.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1021[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1030 := &x.ObjectMeta
					yy1030.CodecEncodeSelf(e)
				}
			}
			if yyr1021 || yy2arr1021 {
				if yyq1021[3] {
					yy1032 := &x.Spec
					yy1032.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1021[3] {
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					yy1033 := &x.Spec
					yy1033.CodecEncodeSelf(e)
				}
			}
			if yysep1021 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1041 int
	var yyb1041 bool
	var yyhl1041 bool = l >= 0
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1044 := &x.ObjectMeta
		yyv1044.CodecDecodeSelf(d)
	}
	yyj1041++
	if yyhl1041 {
		yyb1041 = yyj1041 > l
	} else {
		yyb1041 = r.CheckBreak()
	}
	if yyb1041 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Spec = ClusterAutoscalerSpec{}
	} else {
		yyv1045 := &x.Spec
		yyv1045.CodecDecodeSelf(d)
	}
	for {
		yyj1041++
		if yyhl1041 {
			yyb1041 = yyj1041 > l
		} else {
			yyb1041 = r.CheckBreak()
		}
		if yyb1041 {
			break
		}
		z.DecStructFieldNotFound(yyj1041-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 {
		yym1046 := z.EncBinary()
		_ = yym1046
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1047 := !z.EncBinary()
			yy2arr1047 := z.EncBasicHandle().StructToArray
			var yyq1047 [4]bool
			_, _, _ = yysep1047, yyq1047, yy2arr1047
			const yyr1047 bool = false
			yyq1047[0] = x.Kind != ""
			yyq1047[1] = x.APIVersion != ""
			yyq1047[2] = true
			if yyr1047 || yy2arr1047 {
				r.EncodeArrayStart(4)
			} else {
				var yynn1047 int = 1
				for _, b := range yyq1047 {
					if b {
						yynn1047++
					}
				}
				r.EncodeMapStart(yynn1047)
			}
			if yyr1047 || yy2arr1047 {
				if yyq1047[0] {
					yym1049 := z.EncBinary()
					_ = yym1049
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1047[0] {
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					yym1050 := z.EncBinary()
					_ = yym1050
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1047 || yy2arr1047 {
				if yyq1047[1] {
					yym1052 := z.EncBinary()
					_ = yym1052
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1047[1] {
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					yym1053 := z.EncBinary()
					_ = yym1053
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1047 || yy2arr1047 {
				if yyq1047[2] {
					yy1055 := &x.ListMeta
					yym1056 := z.EncBinary()
					_ = yym1056
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1055) {
					} else {
						z.EncFallback(yy1055)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1047[2] {
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					yy1057 := &x.ListMeta
					yym1058 := z.EncBinary()
					_ = yym1058
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1057) {
					} else {
						z.EncFallback(yy1057)
					}
				}
			}
			if yyr1047 || yy2arr1047 {
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1060 := z.EncBinary()
					_ = yym1060
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1061 := z.EncBinary()
					_ = yym1061
					if false {
					} else {
						h.encSliceClusterAutoscaler(([]ClusterAutoscaler)(x.Items), e)
					}
				}
			}
			if yysep1047 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *ClusterAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1071 int
	var yyb1071 bool
	var yyhl1071 bool = l >= 0
	yyj1071++
	if yyhl1071 {
		yyb1071 = yyj1071 > l
	} else {
		yyb1071 = r.CheckBreak()
	}
	if yyb1071 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1071++
	if yyhl1071 {
		yyb1071 = yyj1071 > l
	} else {
		yyb1071 = r.CheckBreak()
	}
	if yyb1071 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1071++
	if yyhl1071 {
		yyb1071 = yyj1071 > l
	} else {
		yyb1071 = r.CheckBreak()
	}
	if yyb1071 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1074 := &x.ListMeta
		yym1075 := z.DecBinary()
		_ = yym1075
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1074) {
		} else {
			z.DecFallback(yyv1074, false)
		}
	}
	yyj1071++
	if yyhl1071 {
		yyb1071 = yyj1071 > l
	} else {
		yyb1071 = r.CheckBreak()
	}
	if yyb1071 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1076 := &x.Items
		yym1077 := z.DecBinary()
		_ = yym1077
		if false {
		} else {
			h.decSliceClusterAutoscaler((*[]ClusterAutoscaler)(yyv1076), d)
		}
	}
	for {
		yyj1071++
		if yyhl1071 {
			yyb1071 = yyj1071 > l
		} else {
			yyb1071 = r.CheckBreak()
		}
		if yyb1071 {
			break
		}
		z.DecStructFieldNotFound(yyj1071-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 {
		yym1078 := z.EncBinary()
		_ = yym1078
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1079 := !z.EncBinary()
			yy2arr1079 := z.EncBasicHandle().StructToArray
			var yyq1079 [2]bool
			_, _, _ = yysep1079, yyq1079, yy2arr1079
			const yyr1079 bool = false
			yyq1079[0] = len(x.MatchLabels) != 0
			yyq1079[1] = len(x.MatchExpressions) != 0
			if yyr1079 || yy2arr1079 {
				r.EncodeArrayStart(2)
			} else {
				var yynn1079 int = 0
				for _, b := range yyq1079 {
					if b {
						yynn1079++
					}
				}
				r.EncodeMapStart(yynn1079)
			}
			if yyr1079 || yy2arr1079 {
				if yyq1079[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1081 := z.EncBinary()
						_ = yym1081
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1079[0] {
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1082 := z.EncBinary()
						_ = yym1082
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1079 || yy2arr1079 {
				if yyq1079[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1084 := z.EncBinary()
						_ = yym1084
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1079[1] {
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1085 := z.EncBinary()
						_ = yym1085
						if false {
						} else {
							h.encSlicePodSelectorRequirement(([]PodSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yysep1079 {
				r.EncodeEnd()
			}
		}
	}
}

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

func (x *PodSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1093 int
	var yyb1093 bool
	var yyhl1093 bool = l >= 0
	yyj1093++
	if yyhl1093 {
		yyb1093 = yyj1093 > l
	} else {
		yyb1093 = r.CheckBreak()
	}
	if yyb1093 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1094 := &x.MatchLabels
		yym1095 := z.DecBinary()
		_ = yym1095
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1094, false, d)
		}
	}
	yyj1093++
	if yyhl1093 {
		yyb1093 = yyj1093 > l
	} else {
		yyb1093 = r.CheckBreak()
	}
	if yyb1093 {
		r.ReadEnd()
		return
	}
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1096 := &x.MatchExpressions
		yym1097 := z.DecBinary()
		_ = yym1097
		if false {
		} else {
			h.decSlicePodSelectorRequirement((*[]PodSelectorRequirement)(yyv1096), d)
		}
	}
	for {
		yyj1093++
		if yyhl1093 {
			yyb1093 = yyj1093 > l
		} else {
			yyb1093 = r.CheckBreak()
		}
		if yyb1093 {
			break
		}
		z.DecStructFieldNotFound(yyj1093-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 {
		yym1098 := z.EncBinary()
		_ = yym1098
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1099 := !z.EncBinary()
			yy2arr1099 := z.EncBasicHandle().StructToArray
			var yyq1099 [3]bool
			_, _, _ = yysep1099, yyq1099, yy2arr1099
			const yyr1099 bool = false
			yyq1099[2] = len(x.Values) != 0
			if yyr1099 || yy2arr1099 {
				r.EncodeArrayStart(3)
			} else {
				var yynn1099 int = 2
				for _, b := range yyq1099 {
					if b {
						yynn1099++
					}
				}
				r.EncodeMapStart(yynn1099)
			}
			if yyr1099 || yy2arr1099 {
				yym1101 := z.EncBinary()
				_ = yym1101
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				yym1102 := z.EncBinary()
				_ = yym1102
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1099 || yy2arr1099 {
				x.Operator.CodecEncodeSelf(e)
			} else {
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1099 || yy2arr1099 {
				if yyq1099[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1105 := z.EncBinary()
						_ = yym1105
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1099[2] {
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1106 := z.EncBinary()
						_ = yym1106
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yysep1099 {
				r.EncodeEnd()
			}
		}
	}
}

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

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

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

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

	yyv1123 := *v
	yyh1123, yyl1123 := z.DecSliceHelperStart()

	var yyrr1123, yyrl1123 int
	var yyc1123, yyrt1123 bool
	_, _, _ = yyc1123, yyrt1123, yyrl1123
	yyrr1123 = yyl1123

	if yyv1123 == nil {
		if yyrl1123, yyrt1123 = z.DecInferLen(yyl1123, z.DecBasicHandle().MaxInitLen, 320); yyrt1123 {
			yyrr1123 = yyrl1123
		}
		yyv1123 = make([]HorizontalPodAutoscaler, yyrl1123)
		yyc1123 = true
	}

	if yyl1123 == 0 {
		if len(yyv1123) != 0 {
			yyv1123 = yyv1123[:0]
			yyc1123 = true
		}
	} else if yyl1123 > 0 {

		if yyl1123 > cap(yyv1123) {
			yyrl1123, yyrt1123 = z.DecInferLen(yyl1123, z.DecBasicHandle().MaxInitLen, 320)
			yyv1123 = make([]HorizontalPodAutoscaler, yyrl1123)
			yyc1123 = true

			yyrr1123 = len(yyv1123)
		} else if yyl1123 != len(yyv1123) {
			yyv1123 = yyv1123[:yyl1123]
			yyc1123 = true
		}
		yyj1123 := 0
		for ; yyj1123 < yyrr1123; yyj1123++ {
			if r.TryDecodeAsNil() {
				yyv1123[yyj1123] = HorizontalPodAutoscaler{}
			} else {
				yyv1124 := &yyv1123[yyj1123]
				yyv1124.CodecDecodeSelf(d)
			}

		}
		if yyrt1123 {
			for ; yyj1123 < yyl1123; yyj1123++ {
				yyv1123 = append(yyv1123, HorizontalPodAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1123[yyj1123] = HorizontalPodAutoscaler{}
				} else {
					yyv1125 := &yyv1123[yyj1123]
					yyv1125.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1123 := 0; !r.CheckBreak(); yyj1123++ {
			if yyj1123 >= len(yyv1123) {
				yyv1123 = append(yyv1123, HorizontalPodAutoscaler{}) // var yyz1123 HorizontalPodAutoscaler
				yyc1123 = true
			}

			if yyj1123 < len(yyv1123) {
				if r.TryDecodeAsNil() {
					yyv1123[yyj1123] = HorizontalPodAutoscaler{}
				} else {
					yyv1126 := &yyv1123[yyj1123]
					yyv1126.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1123.End()
	}
	if yyc1123 {
		*v = yyv1123
	}

}

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

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

	yyv1129 := *v
	yyh1129, yyl1129 := z.DecSliceHelperStart()

	var yyrr1129, yyrl1129 int
	var yyc1129, yyrt1129 bool
	_, _, _ = yyc1129, yyrt1129, yyrl1129
	yyrr1129 = yyl1129

	if yyv1129 == nil {
		if yyrl1129, yyrt1129 = z.DecInferLen(yyl1129, z.DecBasicHandle().MaxInitLen, 32); yyrt1129 {
			yyrr1129 = yyrl1129
		}
		yyv1129 = make([]APIVersion, yyrl1129)
		yyc1129 = true
	}

	if yyl1129 == 0 {
		if len(yyv1129) != 0 {
			yyv1129 = yyv1129[:0]
			yyc1129 = true
		}
	} else if yyl1129 > 0 {

		if yyl1129 > cap(yyv1129) {
			yyrl1129, yyrt1129 = z.DecInferLen(yyl1129, z.DecBasicHandle().MaxInitLen, 32)
			yyv1129 = make([]APIVersion, yyrl1129)
			yyc1129 = true

			yyrr1129 = len(yyv1129)
		} else if yyl1129 != len(yyv1129) {
			yyv1129 = yyv1129[:yyl1129]
			yyc1129 = true
		}
		yyj1129 := 0
		for ; yyj1129 < yyrr1129; yyj1129++ {
			if r.TryDecodeAsNil() {
				yyv1129[yyj1129] = APIVersion{}
			} else {
				yyv1130 := &yyv1129[yyj1129]
				yyv1130.CodecDecodeSelf(d)
			}

		}
		if yyrt1129 {
			for ; yyj1129 < yyl1129; yyj1129++ {
				yyv1129 = append(yyv1129, APIVersion{})
				if r.TryDecodeAsNil() {
					yyv1129[yyj1129] = APIVersion{}
				} else {
					yyv1131 := &yyv1129[yyj1129]
					yyv1131.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1129 := 0; !r.CheckBreak(); yyj1129++ {
			if yyj1129 >= len(yyv1129) {
				yyv1129 = append(yyv1129, APIVersion{}) // var yyz1129 APIVersion
				yyc1129 = true
			}

			if yyj1129 < len(yyv1129) {
				if r.TryDecodeAsNil() {
					yyv1129[yyj1129] = APIVersion{}
				} else {
					yyv1132 := &yyv1129[yyj1129]
					yyv1132.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1129.End()
	}
	if yyc1129 {
		*v = yyv1129
	}

}

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

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

	yyv1135 := *v
	yyh1135, yyl1135 := z.DecSliceHelperStart()

	var yyrr1135, yyrl1135 int
	var yyc1135, yyrt1135 bool
	_, _, _ = yyc1135, yyrt1135, yyrl1135
	yyrr1135 = yyl1135

	if yyv1135 == nil {
		if yyrl1135, yyrt1135 = z.DecInferLen(yyl1135, z.DecBasicHandle().MaxInitLen, 232); yyrt1135 {
			yyrr1135 = yyrl1135
		}
		yyv1135 = make([]ThirdPartyResource, yyrl1135)
		yyc1135 = true
	}

	if yyl1135 == 0 {
		if len(yyv1135) != 0 {
			yyv1135 = yyv1135[:0]
			yyc1135 = true
		}
	} else if yyl1135 > 0 {

		if yyl1135 > cap(yyv1135) {
			yyrl1135, yyrt1135 = z.DecInferLen(yyl1135, z.DecBasicHandle().MaxInitLen, 232)
			yyv1135 = make([]ThirdPartyResource, yyrl1135)
			yyc1135 = true

			yyrr1135 = len(yyv1135)
		} else if yyl1135 != len(yyv1135) {
			yyv1135 = yyv1135[:yyl1135]
			yyc1135 = true
		}
		yyj1135 := 0
		for ; yyj1135 < yyrr1135; yyj1135++ {
			if r.TryDecodeAsNil() {
				yyv1135[yyj1135] = ThirdPartyResource{}
			} else {
				yyv1136 := &yyv1135[yyj1135]
				yyv1136.CodecDecodeSelf(d)
			}

		}
		if yyrt1135 {
			for ; yyj1135 < yyl1135; yyj1135++ {
				yyv1135 = append(yyv1135, ThirdPartyResource{})
				if r.TryDecodeAsNil() {
					yyv1135[yyj1135] = ThirdPartyResource{}
				} else {
					yyv1137 := &yyv1135[yyj1135]
					yyv1137.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1135 := 0; !r.CheckBreak(); yyj1135++ {
			if yyj1135 >= len(yyv1135) {
				yyv1135 = append(yyv1135, ThirdPartyResource{}) // var yyz1135 ThirdPartyResource
				yyc1135 = true
			}

			if yyj1135 < len(yyv1135) {
				if r.TryDecodeAsNil() {
					yyv1135[yyj1135] = ThirdPartyResource{}
				} else {
					yyv1138 := &yyv1135[yyj1135]
					yyv1138.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1135.End()
	}
	if yyc1135 {
		*v = yyv1135
	}

}

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

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

	yyv1141 := *v
	yyh1141, yyl1141 := z.DecSliceHelperStart()

	var yyrr1141, yyrl1141 int
	var yyc1141, yyrt1141 bool
	_, _, _ = yyc1141, yyrt1141, yyrl1141
	yyrr1141 = yyl1141

	if yyv1141 == nil {
		if yyrl1141, yyrt1141 = z.DecInferLen(yyl1141, z.DecBasicHandle().MaxInitLen, 592); yyrt1141 {
			yyrr1141 = yyrl1141
		}
		yyv1141 = make([]Deployment, yyrl1141)
		yyc1141 = true
	}

	if yyl1141 == 0 {
		if len(yyv1141) != 0 {
			yyv1141 = yyv1141[:0]
			yyc1141 = true
		}
	} else if yyl1141 > 0 {

		if yyl1141 > cap(yyv1141) {
			yyrl1141, yyrt1141 = z.DecInferLen(yyl1141, z.DecBasicHandle().MaxInitLen, 592)
			yyv1141 = make([]Deployment, yyrl1141)
			yyc1141 = true

			yyrr1141 = len(yyv1141)
		} else if yyl1141 != len(yyv1141) {
			yyv1141 = yyv1141[:yyl1141]
			yyc1141 = true
		}
		yyj1141 := 0
		for ; yyj1141 < yyrr1141; yyj1141++ {
			if r.TryDecodeAsNil() {
				yyv1141[yyj1141] = Deployment{}
			} else {
				yyv1142 := &yyv1141[yyj1141]
				yyv1142.CodecDecodeSelf(d)
			}

		}
		if yyrt1141 {
			for ; yyj1141 < yyl1141; yyj1141++ {
				yyv1141 = append(yyv1141, Deployment{})
				if r.TryDecodeAsNil() {
					yyv1141[yyj1141] = Deployment{}
				} else {
					yyv1143 := &yyv1141[yyj1141]
					yyv1143.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1141 := 0; !r.CheckBreak(); yyj1141++ {
			if yyj1141 >= len(yyv1141) {
				yyv1141 = append(yyv1141, Deployment{}) // var yyz1141 Deployment
				yyc1141 = true
			}

			if yyj1141 < len(yyv1141) {
				if r.TryDecodeAsNil() {
					yyv1141[yyj1141] = Deployment{}
				} else {
					yyv1144 := &yyv1141[yyj1141]
					yyv1144.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1141.End()
	}
	if yyc1141 {
		*v = yyv1141
	}

}

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

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

	yyv1147 := *v
	yyh1147, yyl1147 := z.DecSliceHelperStart()

	var yyrr1147, yyrl1147 int
	var yyc1147, yyrt1147 bool
	_, _, _ = yyc1147, yyrt1147, yyrl1147
	yyrr1147 = yyl1147

	if yyv1147 == nil {
		if yyrl1147, yyrt1147 = z.DecInferLen(yyl1147, z.DecBasicHandle().MaxInitLen, 232); yyrt1147 {
			yyrr1147 = yyrl1147
		}
		yyv1147 = make([]DaemonSet, yyrl1147)
		yyc1147 = true
	}

	if yyl1147 == 0 {
		if len(yyv1147) != 0 {
			yyv1147 = yyv1147[:0]
			yyc1147 = true
		}
	} else if yyl1147 > 0 {

		if yyl1147 > cap(yyv1147) {
			yyrl1147, yyrt1147 = z.DecInferLen(yyl1147, z.DecBasicHandle().MaxInitLen, 232)
			yyv1147 = make([]DaemonSet, yyrl1147)
			yyc1147 = true

			yyrr1147 = len(yyv1147)
		} else if yyl1147 != len(yyv1147) {
			yyv1147 = yyv1147[:yyl1147]
			yyc1147 = true
		}
		yyj1147 := 0
		for ; yyj1147 < yyrr1147; yyj1147++ {
			if r.TryDecodeAsNil() {
				yyv1147[yyj1147] = DaemonSet{}
			} else {
				yyv1148 := &yyv1147[yyj1147]
				yyv1148.CodecDecodeSelf(d)
			}

		}
		if yyrt1147 {
			for ; yyj1147 < yyl1147; yyj1147++ {
				yyv1147 = append(yyv1147, DaemonSet{})
				if r.TryDecodeAsNil() {
					yyv1147[yyj1147] = DaemonSet{}
				} else {
					yyv1149 := &yyv1147[yyj1147]
					yyv1149.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1147 := 0; !r.CheckBreak(); yyj1147++ {
			if yyj1147 >= len(yyv1147) {
				yyv1147 = append(yyv1147, DaemonSet{}) // var yyz1147 DaemonSet
				yyc1147 = true
			}

			if yyj1147 < len(yyv1147) {
				if r.TryDecodeAsNil() {
					yyv1147[yyj1147] = DaemonSet{}
				} else {
					yyv1150 := &yyv1147[yyj1147]
					yyv1150.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1147.End()
	}
	if yyc1147 {
		*v = yyv1147
	}

}

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

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

	yyv1153 := *v
	yyh1153, yyl1153 := z.DecSliceHelperStart()

	var yyrr1153, yyrl1153 int
	var yyc1153, yyrt1153 bool
	_, _, _ = yyc1153, yyrt1153, yyrl1153
	yyrr1153 = yyl1153

	if yyv1153 == nil {
		if yyrl1153, yyrt1153 = z.DecInferLen(yyl1153, z.DecBasicHandle().MaxInitLen, 216); yyrt1153 {
			yyrr1153 = yyrl1153
		}
		yyv1153 = make([]ThirdPartyResourceData, yyrl1153)
		yyc1153 = true
	}

	if yyl1153 == 0 {
		if len(yyv1153) != 0 {
			yyv1153 = yyv1153[:0]
			yyc1153 = true
		}
	} else if yyl1153 > 0 {

		if yyl1153 > cap(yyv1153) {
			yyrl1153, yyrt1153 = z.DecInferLen(yyl1153, z.DecBasicHandle().MaxInitLen, 216)
			yyv1153 = make([]ThirdPartyResourceData, yyrl1153)
			yyc1153 = true

			yyrr1153 = len(yyv1153)
		} else if yyl1153 != len(yyv1153) {
			yyv1153 = yyv1153[:yyl1153]
			yyc1153 = true
		}
		yyj1153 := 0
		for ; yyj1153 < yyrr1153; yyj1153++ {
			if r.TryDecodeAsNil() {
				yyv1153[yyj1153] = ThirdPartyResourceData{}
			} else {
				yyv1154 := &yyv1153[yyj1153]
				yyv1154.CodecDecodeSelf(d)
			}

		}
		if yyrt1153 {
			for ; yyj1153 < yyl1153; yyj1153++ {
				yyv1153 = append(yyv1153, ThirdPartyResourceData{})
				if r.TryDecodeAsNil() {
					yyv1153[yyj1153] = ThirdPartyResourceData{}
				} else {
					yyv1155 := &yyv1153[yyj1153]
					yyv1155.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1153 := 0; !r.CheckBreak(); yyj1153++ {
			if yyj1153 >= len(yyv1153) {
				yyv1153 = append(yyv1153, ThirdPartyResourceData{}) // var yyz1153 ThirdPartyResourceData
				yyc1153 = true
			}

			if yyj1153 < len(yyv1153) {
				if r.TryDecodeAsNil() {
					yyv1153[yyj1153] = ThirdPartyResourceData{}
				} else {
					yyv1156 := &yyv1153[yyj1153]
					yyv1156.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1153.End()
	}
	if yyc1153 {
		*v = yyv1153
	}

}

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

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

	yyv1159 := *v
	yyh1159, yyl1159 := z.DecSliceHelperStart()

	var yyrr1159, yyrl1159 int
	var yyc1159, yyrt1159 bool
	_, _, _ = yyc1159, yyrt1159, yyrl1159
	yyrr1159 = yyl1159

	if yyv1159 == nil {
		if yyrl1159, yyrt1159 = z.DecInferLen(yyl1159, z.DecBasicHandle().MaxInitLen, 608); yyrt1159 {
			yyrr1159 = yyrl1159
		}
		yyv1159 = make([]Job, yyrl1159)
		yyc1159 = true
	}

	if yyl1159 == 0 {
		if len(yyv1159) != 0 {
			yyv1159 = yyv1159[:0]
			yyc1159 = true
		}
	} else if yyl1159 > 0 {

		if yyl1159 > cap(yyv1159) {
			yyrl1159, yyrt1159 = z.DecInferLen(yyl1159, z.DecBasicHandle().MaxInitLen, 608)
			yyv1159 = make([]Job, yyrl1159)
			yyc1159 = true

			yyrr1159 = len(yyv1159)
		} else if yyl1159 != len(yyv1159) {
			yyv1159 = yyv1159[:yyl1159]
			yyc1159 = true
		}
		yyj1159 := 0
		for ; yyj1159 < yyrr1159; yyj1159++ {
			if r.TryDecodeAsNil() {
				yyv1159[yyj1159] = Job{}
			} else {
				yyv1160 := &yyv1159[yyj1159]
				yyv1160.CodecDecodeSelf(d)
			}

		}
		if yyrt1159 {
			for ; yyj1159 < yyl1159; yyj1159++ {
				yyv1159 = append(yyv1159, Job{})
				if r.TryDecodeAsNil() {
					yyv1159[yyj1159] = Job{}
				} else {
					yyv1161 := &yyv1159[yyj1159]
					yyv1161.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1159 := 0; !r.CheckBreak(); yyj1159++ {
			if yyj1159 >= len(yyv1159) {
				yyv1159 = append(yyv1159, Job{}) // var yyz1159 Job
				yyc1159 = true
			}

			if yyj1159 < len(yyv1159) {
				if r.TryDecodeAsNil() {
					yyv1159[yyj1159] = Job{}
				} else {
					yyv1162 := &yyv1159[yyj1159]
					yyv1162.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1159.End()
	}
	if yyc1159 {
		*v = yyv1159
	}

}

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

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

	yyv1165 := *v
	yyh1165, yyl1165 := z.DecSliceHelperStart()

	var yyrr1165, yyrl1165 int
	var yyc1165, yyrt1165 bool
	_, _, _ = yyc1165, yyrt1165, yyrl1165
	yyrr1165 = yyl1165

	if yyv1165 == nil {
		if yyrl1165, yyrt1165 = z.DecInferLen(yyl1165, z.DecBasicHandle().MaxInitLen, 112); yyrt1165 {
			yyrr1165 = yyrl1165
		}
		yyv1165 = make([]JobCondition, yyrl1165)
		yyc1165 = true
	}

	if yyl1165 == 0 {
		if len(yyv1165) != 0 {
			yyv1165 = yyv1165[:0]
			yyc1165 = true
		}
	} else if yyl1165 > 0 {

		if yyl1165 > cap(yyv1165) {
			yyrl1165, yyrt1165 = z.DecInferLen(yyl1165, z.DecBasicHandle().MaxInitLen, 112)
			yyv1165 = make([]JobCondition, yyrl1165)
			yyc1165 = true

			yyrr1165 = len(yyv1165)
		} else if yyl1165 != len(yyv1165) {
			yyv1165 = yyv1165[:yyl1165]
			yyc1165 = true
		}
		yyj1165 := 0
		for ; yyj1165 < yyrr1165; yyj1165++ {
			if r.TryDecodeAsNil() {
				yyv1165[yyj1165] = JobCondition{}
			} else {
				yyv1166 := &yyv1165[yyj1165]
				yyv1166.CodecDecodeSelf(d)
			}

		}
		if yyrt1165 {
			for ; yyj1165 < yyl1165; yyj1165++ {
				yyv1165 = append(yyv1165, JobCondition{})
				if r.TryDecodeAsNil() {
					yyv1165[yyj1165] = JobCondition{}
				} else {
					yyv1167 := &yyv1165[yyj1165]
					yyv1167.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1165 := 0; !r.CheckBreak(); yyj1165++ {
			if yyj1165 >= len(yyv1165) {
				yyv1165 = append(yyv1165, JobCondition{}) // var yyz1165 JobCondition
				yyc1165 = true
			}

			if yyj1165 < len(yyv1165) {
				if r.TryDecodeAsNil() {
					yyv1165[yyj1165] = JobCondition{}
				} else {
					yyv1168 := &yyv1165[yyj1165]
					yyv1168.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1165.End()
	}
	if yyc1165 {
		*v = yyv1165
	}

}

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

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

	yyv1171 := *v
	yyh1171, yyl1171 := z.DecSliceHelperStart()

	var yyrr1171, yyrl1171 int
	var yyc1171, yyrt1171 bool
	_, _, _ = yyc1171, yyrt1171, yyrl1171
	yyrr1171 = yyl1171

	if yyv1171 == nil {
		if yyrl1171, yyrt1171 = z.DecInferLen(yyl1171, z.DecBasicHandle().MaxInitLen, 248); yyrt1171 {
			yyrr1171 = yyrl1171
		}
		yyv1171 = make([]Ingress, yyrl1171)
		yyc1171 = true
	}

	if yyl1171 == 0 {
		if len(yyv1171) != 0 {
			yyv1171 = yyv1171[:0]
			yyc1171 = true
		}
	} else if yyl1171 > 0 {

		if yyl1171 > cap(yyv1171) {
			yyrl1171, yyrt1171 = z.DecInferLen(yyl1171, z.DecBasicHandle().MaxInitLen, 248)
			yyv1171 = make([]Ingress, yyrl1171)
			yyc1171 = true

			yyrr1171 = len(yyv1171)
		} else if yyl1171 != len(yyv1171) {
			yyv1171 = yyv1171[:yyl1171]
			yyc1171 = true
		}
		yyj1171 := 0
		for ; yyj1171 < yyrr1171; yyj1171++ {
			if r.TryDecodeAsNil() {
				yyv1171[yyj1171] = Ingress{}
			} else {
				yyv1172 := &yyv1171[yyj1171]
				yyv1172.CodecDecodeSelf(d)
			}

		}
		if yyrt1171 {
			for ; yyj1171 < yyl1171; yyj1171++ {
				yyv1171 = append(yyv1171, Ingress{})
				if r.TryDecodeAsNil() {
					yyv1171[yyj1171] = Ingress{}
				} else {
					yyv1173 := &yyv1171[yyj1171]
					yyv1173.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1171 := 0; !r.CheckBreak(); yyj1171++ {
			if yyj1171 >= len(yyv1171) {
				yyv1171 = append(yyv1171, Ingress{}) // var yyz1171 Ingress
				yyc1171 = true
			}

			if yyj1171 < len(yyv1171) {
				if r.TryDecodeAsNil() {
					yyv1171[yyj1171] = Ingress{}
				} else {
					yyv1174 := &yyv1171[yyj1171]
					yyv1174.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1171.End()
	}
	if yyc1171 {
		*v = yyv1171
	}

}

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

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

	yyv1177 := *v
	yyh1177, yyl1177 := z.DecSliceHelperStart()

	var yyrr1177, yyrl1177 int
	var yyc1177, yyrt1177 bool
	_, _, _ = yyc1177, yyrt1177, yyrl1177
	yyrr1177 = yyl1177

	if yyv1177 == nil {
		if yyrl1177, yyrt1177 = z.DecInferLen(yyl1177, z.DecBasicHandle().MaxInitLen, 24); yyrt1177 {
			yyrr1177 = yyrl1177
		}
		yyv1177 = make([]IngressRule, yyrl1177)
		yyc1177 = true
	}

	if yyl1177 == 0 {
		if len(yyv1177) != 0 {
			yyv1177 = yyv1177[:0]
			yyc1177 = true
		}
	} else if yyl1177 > 0 {

		if yyl1177 > cap(yyv1177) {
			yyrl1177, yyrt1177 = z.DecInferLen(yyl1177, z.DecBasicHandle().MaxInitLen, 24)
			yyv1177 = make([]IngressRule, yyrl1177)
			yyc1177 = true

			yyrr1177 = len(yyv1177)
		} else if yyl1177 != len(yyv1177) {
			yyv1177 = yyv1177[:yyl1177]
			yyc1177 = true
		}
		yyj1177 := 0
		for ; yyj1177 < yyrr1177; yyj1177++ {
			if r.TryDecodeAsNil() {
				yyv1177[yyj1177] = IngressRule{}
			} else {
				yyv1178 := &yyv1177[yyj1177]
				yyv1178.CodecDecodeSelf(d)
			}

		}
		if yyrt1177 {
			for ; yyj1177 < yyl1177; yyj1177++ {
				yyv1177 = append(yyv1177, IngressRule{})
				if r.TryDecodeAsNil() {
					yyv1177[yyj1177] = IngressRule{}
				} else {
					yyv1179 := &yyv1177[yyj1177]
					yyv1179.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1177 := 0; !r.CheckBreak(); yyj1177++ {
			if yyj1177 >= len(yyv1177) {
				yyv1177 = append(yyv1177, IngressRule{}) // var yyz1177 IngressRule
				yyc1177 = true
			}

			if yyj1177 < len(yyv1177) {
				if r.TryDecodeAsNil() {
					yyv1177[yyj1177] = IngressRule{}
				} else {
					yyv1180 := &yyv1177[yyj1177]
					yyv1180.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1177.End()
	}
	if yyc1177 {
		*v = yyv1177
	}

}

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

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

	yyv1183 := *v
	yyh1183, yyl1183 := z.DecSliceHelperStart()

	var yyrr1183, yyrl1183 int
	var yyc1183, yyrt1183 bool
	_, _, _ = yyc1183, yyrt1183, yyrl1183
	yyrr1183 = yyl1183

	if yyv1183 == nil {
		if yyrl1183, yyrt1183 = z.DecInferLen(yyl1183, z.DecBasicHandle().MaxInitLen, 64); yyrt1183 {
			yyrr1183 = yyrl1183
		}
		yyv1183 = make([]HTTPIngressPath, yyrl1183)
		yyc1183 = true
	}

	if yyl1183 == 0 {
		if len(yyv1183) != 0 {
			yyv1183 = yyv1183[:0]
			yyc1183 = true
		}
	} else if yyl1183 > 0 {

		if yyl1183 > cap(yyv1183) {
			yyrl1183, yyrt1183 = z.DecInferLen(yyl1183, z.DecBasicHandle().MaxInitLen, 64)
			yyv1183 = make([]HTTPIngressPath, yyrl1183)
			yyc1183 = true

			yyrr1183 = len(yyv1183)
		} else if yyl1183 != len(yyv1183) {
			yyv1183 = yyv1183[:yyl1183]
			yyc1183 = true
		}
		yyj1183 := 0
		for ; yyj1183 < yyrr1183; yyj1183++ {
			if r.TryDecodeAsNil() {
				yyv1183[yyj1183] = HTTPIngressPath{}
			} else {
				yyv1184 := &yyv1183[yyj1183]
				yyv1184.CodecDecodeSelf(d)
			}

		}
		if yyrt1183 {
			for ; yyj1183 < yyl1183; yyj1183++ {
				yyv1183 = append(yyv1183, HTTPIngressPath{})
				if r.TryDecodeAsNil() {
					yyv1183[yyj1183] = HTTPIngressPath{}
				} else {
					yyv1185 := &yyv1183[yyj1183]
					yyv1185.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1183 := 0; !r.CheckBreak(); yyj1183++ {
			if yyj1183 >= len(yyv1183) {
				yyv1183 = append(yyv1183, HTTPIngressPath{}) // var yyz1183 HTTPIngressPath
				yyc1183 = true
			}

			if yyj1183 < len(yyv1183) {
				if r.TryDecodeAsNil() {
					yyv1183[yyj1183] = HTTPIngressPath{}
				} else {
					yyv1186 := &yyv1183[yyj1183]
					yyv1186.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1183.End()
	}
	if yyc1183 {
		*v = yyv1183
	}

}

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

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

	yyv1189 := *v
	yyh1189, yyl1189 := z.DecSliceHelperStart()

	var yyrr1189, yyrl1189 int
	var yyc1189, yyrt1189 bool
	_, _, _ = yyc1189, yyrt1189, yyrl1189
	yyrr1189 = yyl1189

	if yyv1189 == nil {
		if yyrl1189, yyrt1189 = z.DecInferLen(yyl1189, z.DecBasicHandle().MaxInitLen, 24); yyrt1189 {
			yyrr1189 = yyrl1189
		}
		yyv1189 = make([]NodeUtilization, yyrl1189)
		yyc1189 = true
	}

	if yyl1189 == 0 {
		if len(yyv1189) != 0 {
			yyv1189 = yyv1189[:0]
			yyc1189 = true
		}
	} else if yyl1189 > 0 {

		if yyl1189 > cap(yyv1189) {
			yyrl1189, yyrt1189 = z.DecInferLen(yyl1189, z.DecBasicHandle().MaxInitLen, 24)
			yyv1189 = make([]NodeUtilization, yyrl1189)
			yyc1189 = true

			yyrr1189 = len(yyv1189)
		} else if yyl1189 != len(yyv1189) {
			yyv1189 = yyv1189[:yyl1189]
			yyc1189 = true
		}
		yyj1189 := 0
		for ; yyj1189 < yyrr1189; yyj1189++ {
			if r.TryDecodeAsNil() {
				yyv1189[yyj1189] = NodeUtilization{}
			} else {
				yyv1190 := &yyv1189[yyj1189]
				yyv1190.CodecDecodeSelf(d)
			}

		}
		if yyrt1189 {
			for ; yyj1189 < yyl1189; yyj1189++ {
				yyv1189 = append(yyv1189, NodeUtilization{})
				if r.TryDecodeAsNil() {
					yyv1189[yyj1189] = NodeUtilization{}
				} else {
					yyv1191 := &yyv1189[yyj1189]
					yyv1191.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1189 := 0; !r.CheckBreak(); yyj1189++ {
			if yyj1189 >= len(yyv1189) {
				yyv1189 = append(yyv1189, NodeUtilization{}) // var yyz1189 NodeUtilization
				yyc1189 = true
			}

			if yyj1189 < len(yyv1189) {
				if r.TryDecodeAsNil() {
					yyv1189[yyj1189] = NodeUtilization{}
				} else {
					yyv1192 := &yyv1189[yyj1189]
					yyv1192.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1189.End()
	}
	if yyc1189 {
		*v = yyv1189
	}

}

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

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

	yyv1195 := *v
	yyh1195, yyl1195 := z.DecSliceHelperStart()

	var yyrr1195, yyrl1195 int
	var yyc1195, yyrt1195 bool
	_, _, _ = yyc1195, yyrt1195, yyrl1195
	yyrr1195 = yyl1195

	if yyv1195 == nil {
		if yyrl1195, yyrt1195 = z.DecInferLen(yyl1195, z.DecBasicHandle().MaxInitLen, 232); yyrt1195 {
			yyrr1195 = yyrl1195
		}
		yyv1195 = make([]ClusterAutoscaler, yyrl1195)
		yyc1195 = true
	}

	if yyl1195 == 0 {
		if len(yyv1195) != 0 {
			yyv1195 = yyv1195[:0]
			yyc1195 = true
		}
	} else if yyl1195 > 0 {

		if yyl1195 > cap(yyv1195) {
			yyrl1195, yyrt1195 = z.DecInferLen(yyl1195, z.DecBasicHandle().MaxInitLen, 232)
			yyv1195 = make([]ClusterAutoscaler, yyrl1195)
			yyc1195 = true

			yyrr1195 = len(yyv1195)
		} else if yyl1195 != len(yyv1195) {
			yyv1195 = yyv1195[:yyl1195]
			yyc1195 = true
		}
		yyj1195 := 0
		for ; yyj1195 < yyrr1195; yyj1195++ {
			if r.TryDecodeAsNil() {
				yyv1195[yyj1195] = ClusterAutoscaler{}
			} else {
				yyv1196 := &yyv1195[yyj1195]
				yyv1196.CodecDecodeSelf(d)
			}

		}
		if yyrt1195 {
			for ; yyj1195 < yyl1195; yyj1195++ {
				yyv1195 = append(yyv1195, ClusterAutoscaler{})
				if r.TryDecodeAsNil() {
					yyv1195[yyj1195] = ClusterAutoscaler{}
				} else {
					yyv1197 := &yyv1195[yyj1195]
					yyv1197.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1195 := 0; !r.CheckBreak(); yyj1195++ {
			if yyj1195 >= len(yyv1195) {
				yyv1195 = append(yyv1195, ClusterAutoscaler{}) // var yyz1195 ClusterAutoscaler
				yyc1195 = true
			}

			if yyj1195 < len(yyv1195) {
				if r.TryDecodeAsNil() {
					yyv1195[yyj1195] = ClusterAutoscaler{}
				} else {
					yyv1198 := &yyv1195[yyj1195]
					yyv1198.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1195.End()
	}
	if yyc1195 {
		*v = yyv1195
	}

}

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

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

	yyv1201 := *v
	yyh1201, yyl1201 := z.DecSliceHelperStart()

	var yyrr1201, yyrl1201 int
	var yyc1201, yyrt1201 bool
	_, _, _ = yyc1201, yyrt1201, yyrl1201
	yyrr1201 = yyl1201

	if yyv1201 == nil {
		if yyrl1201, yyrt1201 = z.DecInferLen(yyl1201, z.DecBasicHandle().MaxInitLen, 56); yyrt1201 {
			yyrr1201 = yyrl1201
		}
		yyv1201 = make([]PodSelectorRequirement, yyrl1201)
		yyc1201 = true
	}

	if yyl1201 == 0 {
		if len(yyv1201) != 0 {
			yyv1201 = yyv1201[:0]
			yyc1201 = true
		}
	} else if yyl1201 > 0 {

		if yyl1201 > cap(yyv1201) {
			yyrl1201, yyrt1201 = z.DecInferLen(yyl1201, z.DecBasicHandle().MaxInitLen, 56)
			yyv1201 = make([]PodSelectorRequirement, yyrl1201)
			yyc1201 = true

			yyrr1201 = len(yyv1201)
		} else if yyl1201 != len(yyv1201) {
			yyv1201 = yyv1201[:yyl1201]
			yyc1201 = true
		}
		yyj1201 := 0
		for ; yyj1201 < yyrr1201; yyj1201++ {
			if r.TryDecodeAsNil() {
				yyv1201[yyj1201] = PodSelectorRequirement{}
			} else {
				yyv1202 := &yyv1201[yyj1201]
				yyv1202.CodecDecodeSelf(d)
			}

		}
		if yyrt1201 {
			for ; yyj1201 < yyl1201; yyj1201++ {
				yyv1201 = append(yyv1201, PodSelectorRequirement{})
				if r.TryDecodeAsNil() {
					yyv1201[yyj1201] = PodSelectorRequirement{}
				} else {
					yyv1203 := &yyv1201[yyj1201]
					yyv1203.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		for yyj1201 := 0; !r.CheckBreak(); yyj1201++ {
			if yyj1201 >= len(yyv1201) {
				yyv1201 = append(yyv1201, PodSelectorRequirement{}) // var yyz1201 PodSelectorRequirement
				yyc1201 = true
			}

			if yyj1201 < len(yyv1201) {
				if r.TryDecodeAsNil() {
					yyv1201[yyj1201] = PodSelectorRequirement{}
				} else {
					yyv1204 := &yyv1201[yyj1201]
					yyv1204.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		yyh1201.End()
	}
	if yyc1201 {
		*v = yyv1201
	}

}