types.generated.go

/*
Copyright 2016 The Kubernetes Authors.

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

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

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

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

package v1beta1

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg4_resource "k8s.io/kubernetes/pkg/api/resource"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	pkg2_v1 "k8s.io/kubernetes/pkg/api/v1"
	pkg3_types "k8s.io/kubernetes/pkg/types"
	pkg5_intstr "k8s.io/kubernetes/pkg/util/intstr"
	"reflect"
	"runtime"
	time "time"
)

const (
	// ----- content types ----
	codecSelferC_UTF81234 = 1
	codecSelferC_RAW1234  = 0
	// ----- value types used ----
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey1234    = 2
	codecSelfer_containerMapValue1234  = 3
	codecSelfer_containerMapEnd1234    = 4
	codecSelfer_containerArrayElem1234 = 6
	codecSelfer_containerArrayEnd1234  = 7
)

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 != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg4_resource.Quantity
		var v1 pkg1_unversioned.TypeMeta
		var v2 pkg2_v1.ObjectMeta
		var v3 pkg3_types.UID
		var v4 pkg5_intstr.IntOrString
		var v5 time.Time
		_, _, _, _, _, _ = v0, v1, v2, v3, v4, v5
	}
}

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
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 0
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq2[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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 {
		yyct7 := r.ContainerType()
		if yyct7 == codecSelferValueTypeMap1234 {
			yyl7 := r.ReadMapStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl7, d)
			}
		} else if yyct7 == codecSelferValueTypeArray1234 {
			yyl7 := r.ReadArrayStart()
			if yyl7 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} 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
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys8Slc = r.DecodeBytes(yys8Slc, true, true)
		yys8 := string(yys8Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys8 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys8)
		} // end switch yys8
	} // end for yyj8
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

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 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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 [3]bool
			_, _, _ = yysep13, yyq13, yy2arr13
			const yyr13 bool = false
			yyq13[1] = len(x.Selector) != 0
			yyq13[2] = x.TargetSelector != ""
			var yynn13 int
			if yyr13 || yy2arr13 {
				r.EncodeArrayStart(3)
			} else {
				yynn13 = 1
				for _, b := range yyq13 {
					if b {
						yynn13++
					}
				}
				r.EncodeMapStart(yynn13)
				yynn13 = 0
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				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] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym19 := z.EncBinary()
						_ = yym19
						if false {
						} else {
							z.F.EncMapStringStringV(x.Selector, false, e)
						}
					}
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq13[2] {
					yym21 := z.EncBinary()
					_ = yym21
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.TargetSelector))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq13[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("targetSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym22 := z.EncBinary()
					_ = yym22
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.TargetSelector))
					}
				}
			}
			if yyr13 || yy2arr13 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ScaleStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym23 := z.DecBinary()
	_ = yym23
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct24 := r.ContainerType()
		if yyct24 == codecSelferValueTypeMap1234 {
			yyl24 := r.ReadMapStart()
			if yyl24 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl24, d)
			}
		} else if yyct24 == codecSelferValueTypeArray1234 {
			yyl24 := r.ReadArrayStart()
			if yyl24 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl24, 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 yys25Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys25Slc
	var yyhl25 bool = l >= 0
	for yyj25 := 0; ; yyj25++ {
		if yyhl25 {
			if yyj25 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys25Slc = r.DecodeBytes(yys25Slc, true, true)
		yys25 := string(yys25Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys25 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				x.Selector = nil
			} else {
				yyv27 := &x.Selector
				yym28 := z.DecBinary()
				_ = yym28
				if false {
				} else {
					z.F.DecMapStringStringX(yyv27, false, d)
				}
			}
		case "targetSelector":
			if r.TryDecodeAsNil() {
				x.TargetSelector = ""
			} else {
				x.TargetSelector = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys25)
		} // end switch yys25
	} // end for yyj25
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ScaleStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj30 int
	var yyb30 bool
	var yyhl30 bool = l >= 0
	yyj30++
	if yyhl30 {
		yyb30 = yyj30 > l
	} else {
		yyb30 = r.CheckBreak()
	}
	if yyb30 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj30++
	if yyhl30 {
		yyb30 = yyj30 > l
	} else {
		yyb30 = r.CheckBreak()
	}
	if yyb30 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Selector = nil
	} else {
		yyv32 := &x.Selector
		yym33 := z.DecBinary()
		_ = yym33
		if false {
		} else {
			z.F.DecMapStringStringX(yyv32, false, d)
		}
	}
	yyj30++
	if yyhl30 {
		yyb30 = yyj30 > l
	} else {
		yyb30 = r.CheckBreak()
	}
	if yyb30 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetSelector = ""
	} else {
		x.TargetSelector = string(r.DecodeString())
	}
	for {
		yyj30++
		if yyhl30 {
			yyb30 = yyj30 > l
		} else {
			yyb30 = r.CheckBreak()
		}
		if yyb30 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj30-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Scale) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym35 := z.EncBinary()
		_ = yym35
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep36 := !z.EncBinary()
			yy2arr36 := z.EncBasicHandle().StructToArray
			var yyq36 [5]bool
			_, _, _ = yysep36, yyq36, yy2arr36
			const yyr36 bool = false
			yyq36[0] = x.Kind != ""
			yyq36[1] = x.APIVersion != ""
			yyq36[2] = true
			yyq36[3] = true
			yyq36[4] = true
			var yynn36 int
			if yyr36 || yy2arr36 {
				r.EncodeArrayStart(5)
			} else {
				yynn36 = 0
				for _, b := range yyq36 {
					if b {
						yynn36++
					}
				}
				r.EncodeMapStart(yynn36)
				yynn36 = 0
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq36[0] {
					yym38 := z.EncBinary()
					_ = yym38
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq36[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym39 := z.EncBinary()
					_ = yym39
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq36[1] {
					yym41 := z.EncBinary()
					_ = yym41
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq36[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym42 := z.EncBinary()
					_ = yym42
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq36[2] {
					yy44 := &x.ObjectMeta
					yy44.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq36[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy45 := &x.ObjectMeta
					yy45.CodecEncodeSelf(e)
				}
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq36[3] {
					yy47 := &x.Spec
					yy47.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq36[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy48 := &x.Spec
					yy48.CodecEncodeSelf(e)
				}
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq36[4] {
					yy50 := &x.Status
					yy50.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq36[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy51 := &x.Status
					yy51.CodecEncodeSelf(e)
				}
			}
			if yyr36 || yy2arr36 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Scale) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym52 := z.DecBinary()
	_ = yym52
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct53 := r.ContainerType()
		if yyct53 == codecSelferValueTypeMap1234 {
			yyl53 := r.ReadMapStart()
			if yyl53 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl53, d)
			}
		} else if yyct53 == codecSelferValueTypeArray1234 {
			yyl53 := r.ReadArrayStart()
			if yyl53 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl53, 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 yys54Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys54Slc
	var yyhl54 bool = l >= 0
	for yyj54 := 0; ; yyj54++ {
		if yyhl54 {
			if yyj54 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys54Slc = r.DecodeBytes(yys54Slc, true, true)
		yys54 := string(yys54Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys54 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv57 := &x.ObjectMeta
				yyv57.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv58 := &x.Spec
				yyv58.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv59 := &x.Status
				yyv59.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys54)
		} // end switch yys54
	} // end for yyj54
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Scale) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj60 int
	var yyb60 bool
	var yyhl60 bool = l >= 0
	yyj60++
	if yyhl60 {
		yyb60 = yyj60 > l
	} else {
		yyb60 = r.CheckBreak()
	}
	if yyb60 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj60++
	if yyhl60 {
		yyb60 = yyj60 > l
	} else {
		yyb60 = r.CheckBreak()
	}
	if yyb60 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj60++
	if yyhl60 {
		yyb60 = yyj60 > l
	} else {
		yyb60 = r.CheckBreak()
	}
	if yyb60 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv63 := &x.ObjectMeta
		yyv63.CodecDecodeSelf(d)
	}
	yyj60++
	if yyhl60 {
		yyb60 = yyj60 > l
	} else {
		yyb60 = r.CheckBreak()
	}
	if yyb60 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv64 := &x.Spec
		yyv64.CodecDecodeSelf(d)
	}
	yyj60++
	if yyhl60 {
		yyb60 = yyj60 > l
	} else {
		yyb60 = r.CheckBreak()
	}
	if yyb60 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv65 := &x.Status
		yyv65.CodecDecodeSelf(d)
	}
	for {
		yyj60++
		if yyhl60 {
			yyb60 = yyj60 > l
		} else {
			yyb60 = r.CheckBreak()
		}
		if yyb60 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj60-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicationControllerDummy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym66 := z.EncBinary()
		_ = yym66
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep67 := !z.EncBinary()
			yy2arr67 := z.EncBasicHandle().StructToArray
			var yyq67 [2]bool
			_, _, _ = yysep67, yyq67, yy2arr67
			const yyr67 bool = false
			yyq67[0] = x.Kind != ""
			yyq67[1] = x.APIVersion != ""
			var yynn67 int
			if yyr67 || yy2arr67 {
				r.EncodeArrayStart(2)
			} else {
				yynn67 = 0
				for _, b := range yyq67 {
					if b {
						yynn67++
					}
				}
				r.EncodeMapStart(yynn67)
				yynn67 = 0
			}
			if yyr67 || yy2arr67 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq67[0] {
					yym69 := z.EncBinary()
					_ = yym69
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq67[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym70 := z.EncBinary()
					_ = yym70
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr67 || yy2arr67 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq67[1] {
					yym72 := z.EncBinary()
					_ = yym72
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq67[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym73 := z.EncBinary()
					_ = yym73
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr67 || yy2arr67 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicationControllerDummy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym74 := z.DecBinary()
	_ = yym74
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct75 := r.ContainerType()
		if yyct75 == codecSelferValueTypeMap1234 {
			yyl75 := r.ReadMapStart()
			if yyl75 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl75, d)
			}
		} else if yyct75 == codecSelferValueTypeArray1234 {
			yyl75 := r.ReadArrayStart()
			if yyl75 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl75, 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 yys76Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys76Slc
	var yyhl76 bool = l >= 0
	for yyj76 := 0; ; yyj76++ {
		if yyhl76 {
			if yyj76 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys76Slc = r.DecodeBytes(yys76Slc, true, true)
		yys76 := string(yys76Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys76 {
		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, yys76)
		} // end switch yys76
	} // end for yyj76
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

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

func (x *SubresourceReference) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym82 := z.EncBinary()
		_ = yym82
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep83 := !z.EncBinary()
			yy2arr83 := z.EncBasicHandle().StructToArray
			var yyq83 [4]bool
			_, _, _ = yysep83, yyq83, yy2arr83
			const yyr83 bool = false
			yyq83[0] = x.Kind != ""
			yyq83[1] = x.Name != ""
			yyq83[2] = x.APIVersion != ""
			yyq83[3] = x.Subresource != ""
			var yynn83 int
			if yyr83 || yy2arr83 {
				r.EncodeArrayStart(4)
			} else {
				yynn83 = 0
				for _, b := range yyq83 {
					if b {
						yynn83++
					}
				}
				r.EncodeMapStart(yynn83)
				yynn83 = 0
			}
			if yyr83 || yy2arr83 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq83[0] {
					yym85 := z.EncBinary()
					_ = yym85
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq83[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym86 := z.EncBinary()
					_ = yym86
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr83 || yy2arr83 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq83[1] {
					yym88 := z.EncBinary()
					_ = yym88
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq83[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym89 := z.EncBinary()
					_ = yym89
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr83 || yy2arr83 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq83[2] {
					yym91 := z.EncBinary()
					_ = yym91
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq83[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym92 := z.EncBinary()
					_ = yym92
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr83 || yy2arr83 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq83[3] {
					yym94 := z.EncBinary()
					_ = yym94
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq83[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("subresource"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym95 := z.EncBinary()
					_ = yym95
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				}
			}
			if yyr83 || yy2arr83 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SubresourceReference) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym96 := z.DecBinary()
	_ = yym96
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct97 := r.ContainerType()
		if yyct97 == codecSelferValueTypeMap1234 {
			yyl97 := r.ReadMapStart()
			if yyl97 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl97, d)
			}
		} else if yyct97 == codecSelferValueTypeArray1234 {
			yyl97 := r.ReadArrayStart()
			if yyl97 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl97, 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 yys98Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys98Slc
	var yyhl98 bool = l >= 0
	for yyj98 := 0; ; yyj98++ {
		if yyhl98 {
			if yyj98 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys98Slc = r.DecodeBytes(yys98Slc, true, true)
		yys98 := string(yys98Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys98 {
		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, yys98)
		} // end switch yys98
	} // end for yyj98
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SubresourceReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj103 int
	var yyb103 bool
	var yyhl103 bool = l >= 0
	yyj103++
	if yyhl103 {
		yyb103 = yyj103 > l
	} else {
		yyb103 = r.CheckBreak()
	}
	if yyb103 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj103++
	if yyhl103 {
		yyb103 = yyj103 > l
	} else {
		yyb103 = r.CheckBreak()
	}
	if yyb103 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj103++
	if yyhl103 {
		yyb103 = yyj103 > l
	} else {
		yyb103 = r.CheckBreak()
	}
	if yyb103 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj103++
	if yyhl103 {
		yyb103 = yyj103 > l
	} else {
		yyb103 = r.CheckBreak()
	}
	if yyb103 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Subresource = ""
	} else {
		x.Subresource = string(r.DecodeString())
	}
	for {
		yyj103++
		if yyhl103 {
			yyb103 = yyj103 > l
		} else {
			yyb103 = r.CheckBreak()
		}
		if yyb103 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj103-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CPUTargetUtilization) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym108 := z.EncBinary()
		_ = yym108
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep109 := !z.EncBinary()
			yy2arr109 := z.EncBasicHandle().StructToArray
			var yyq109 [1]bool
			_, _, _ = yysep109, yyq109, yy2arr109
			const yyr109 bool = false
			var yynn109 int
			if yyr109 || yy2arr109 {
				r.EncodeArrayStart(1)
			} else {
				yynn109 = 1
				for _, b := range yyq109 {
					if b {
						yynn109++
					}
				}
				r.EncodeMapStart(yynn109)
				yynn109 = 0
			}
			if yyr109 || yy2arr109 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym111 := z.EncBinary()
				_ = yym111
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("targetPercentage"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym112 := z.EncBinary()
				_ = yym112
				if false {
				} else {
					r.EncodeInt(int64(x.TargetPercentage))
				}
			}
			if yyr109 || yy2arr109 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CPUTargetUtilization) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym113 := z.DecBinary()
	_ = yym113
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct114 := r.ContainerType()
		if yyct114 == codecSelferValueTypeMap1234 {
			yyl114 := r.ReadMapStart()
			if yyl114 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl114, d)
			}
		} else if yyct114 == codecSelferValueTypeArray1234 {
			yyl114 := r.ReadArrayStart()
			if yyl114 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl114, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CPUTargetUtilization) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys115Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys115Slc
	var yyhl115 bool = l >= 0
	for yyj115 := 0; ; yyj115++ {
		if yyhl115 {
			if yyj115 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys115Slc = r.DecodeBytes(yys115Slc, true, true)
		yys115 := string(yys115Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys115 {
		case "targetPercentage":
			if r.TryDecodeAsNil() {
				x.TargetPercentage = 0
			} else {
				x.TargetPercentage = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys115)
		} // end switch yys115
	} // end for yyj115
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CPUTargetUtilization) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj117 int
	var yyb117 bool
	var yyhl117 bool = l >= 0
	yyj117++
	if yyhl117 {
		yyb117 = yyj117 > l
	} else {
		yyb117 = r.CheckBreak()
	}
	if yyb117 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetPercentage = 0
	} else {
		x.TargetPercentage = int32(r.DecodeInt(32))
	}
	for {
		yyj117++
		if yyhl117 {
			yyb117 = yyj117 > l
		} else {
			yyb117 = r.CheckBreak()
		}
		if yyb117 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj117-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricTarget) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym119 := z.EncBinary()
		_ = yym119
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep120 := !z.EncBinary()
			yy2arr120 := z.EncBasicHandle().StructToArray
			var yyq120 [2]bool
			_, _, _ = yysep120, yyq120, yy2arr120
			const yyr120 bool = false
			var yynn120 int
			if yyr120 || yy2arr120 {
				r.EncodeArrayStart(2)
			} else {
				yynn120 = 2
				for _, b := range yyq120 {
					if b {
						yynn120++
					}
				}
				r.EncodeMapStart(yynn120)
				yynn120 = 0
			}
			if yyr120 || yy2arr120 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym122 := z.EncBinary()
				_ = yym122
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym123 := z.EncBinary()
				_ = yym123
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr120 || yy2arr120 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy125 := &x.TargetValue
				yym126 := z.EncBinary()
				_ = yym126
				if false {
				} else if z.HasExtensions() && z.EncExt(yy125) {
				} else if !yym126 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy125)
				} else {
					z.EncFallback(yy125)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy127 := &x.TargetValue
				yym128 := z.EncBinary()
				_ = yym128
				if false {
				} else if z.HasExtensions() && z.EncExt(yy127) {
				} else if !yym128 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy127)
				} else {
					z.EncFallback(yy127)
				}
			}
			if yyr120 || yy2arr120 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricTarget) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym129 := z.DecBinary()
	_ = yym129
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct130 := r.ContainerType()
		if yyct130 == codecSelferValueTypeMap1234 {
			yyl130 := r.ReadMapStart()
			if yyl130 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl130, d)
			}
		} else if yyct130 == codecSelferValueTypeArray1234 {
			yyl130 := r.ReadArrayStart()
			if yyl130 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl130, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricTarget) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys131Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys131Slc
	var yyhl131 bool = l >= 0
	for yyj131 := 0; ; yyj131++ {
		if yyhl131 {
			if yyj131 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys131Slc = r.DecodeBytes(yys131Slc, true, true)
		yys131 := string(yys131Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys131 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.TargetValue = pkg4_resource.Quantity{}
			} else {
				yyv133 := &x.TargetValue
				yym134 := z.DecBinary()
				_ = yym134
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv133) {
				} else if !yym134 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv133)
				} else {
					z.DecFallback(yyv133, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys131)
		} // end switch yys131
	} // end for yyj131
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTarget) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj135 int
	var yyb135 bool
	var yyhl135 bool = l >= 0
	yyj135++
	if yyhl135 {
		yyb135 = yyj135 > l
	} else {
		yyb135 = r.CheckBreak()
	}
	if yyb135 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj135++
	if yyhl135 {
		yyb135 = yyj135 > l
	} else {
		yyb135 = r.CheckBreak()
	}
	if yyb135 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetValue = pkg4_resource.Quantity{}
	} else {
		yyv137 := &x.TargetValue
		yym138 := z.DecBinary()
		_ = yym138
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv137) {
		} else if !yym138 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv137)
		} else {
			z.DecFallback(yyv137, false)
		}
	}
	for {
		yyj135++
		if yyhl135 {
			yyb135 = yyj135 > l
		} else {
			yyb135 = r.CheckBreak()
		}
		if yyb135 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj135-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricTargetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym139 := z.EncBinary()
		_ = yym139
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep140 := !z.EncBinary()
			yy2arr140 := z.EncBasicHandle().StructToArray
			var yyq140 [1]bool
			_, _, _ = yysep140, yyq140, yy2arr140
			const yyr140 bool = false
			var yynn140 int
			if yyr140 || yy2arr140 {
				r.EncodeArrayStart(1)
			} else {
				yynn140 = 1
				for _, b := range yyq140 {
					if b {
						yynn140++
					}
				}
				r.EncodeMapStart(yynn140)
				yynn140 = 0
			}
			if yyr140 || yy2arr140 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym142 := z.EncBinary()
					_ = yym142
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym143 := z.EncBinary()
					_ = yym143
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			}
			if yyr140 || yy2arr140 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricTargetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym144 := z.DecBinary()
	_ = yym144
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct145 := r.ContainerType()
		if yyct145 == codecSelferValueTypeMap1234 {
			yyl145 := r.ReadMapStart()
			if yyl145 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl145, d)
			}
		} else if yyct145 == codecSelferValueTypeArray1234 {
			yyl145 := r.ReadArrayStart()
			if yyl145 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl145, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricTargetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys146Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys146Slc
	var yyhl146 bool = l >= 0
	for yyj146 := 0; ; yyj146++ {
		if yyhl146 {
			if yyj146 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys146Slc = r.DecodeBytes(yys146Slc, true, true)
		yys146 := string(yys146Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys146 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv147 := &x.Items
				yym148 := z.DecBinary()
				_ = yym148
				if false {
				} else {
					h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv147), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys146)
		} // end switch yys146
	} // end for yyj146
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricTargetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj149 int
	var yyb149 bool
	var yyhl149 bool = l >= 0
	yyj149++
	if yyhl149 {
		yyb149 = yyj149 > l
	} else {
		yyb149 = r.CheckBreak()
	}
	if yyb149 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv150 := &x.Items
		yym151 := z.DecBinary()
		_ = yym151
		if false {
		} else {
			h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv150), d)
		}
	}
	for {
		yyj149++
		if yyhl149 {
			yyb149 = yyj149 > l
		} else {
			yyb149 = r.CheckBreak()
		}
		if yyb149 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj149-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym152 := z.EncBinary()
		_ = yym152
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep153 := !z.EncBinary()
			yy2arr153 := z.EncBasicHandle().StructToArray
			var yyq153 [2]bool
			_, _, _ = yysep153, yyq153, yy2arr153
			const yyr153 bool = false
			var yynn153 int
			if yyr153 || yy2arr153 {
				r.EncodeArrayStart(2)
			} else {
				yynn153 = 2
				for _, b := range yyq153 {
					if b {
						yynn153++
					}
				}
				r.EncodeMapStart(yynn153)
				yynn153 = 0
			}
			if yyr153 || yy2arr153 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym155 := z.EncBinary()
				_ = yym155
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym156 := z.EncBinary()
				_ = yym156
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr153 || yy2arr153 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy158 := &x.CurrentValue
				yym159 := z.EncBinary()
				_ = yym159
				if false {
				} else if z.HasExtensions() && z.EncExt(yy158) {
				} else if !yym159 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy158)
				} else {
					z.EncFallback(yy158)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy160 := &x.CurrentValue
				yym161 := z.EncBinary()
				_ = yym161
				if false {
				} else if z.HasExtensions() && z.EncExt(yy160) {
				} else if !yym161 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy160)
				} else {
					z.EncFallback(yy160)
				}
			}
			if yyr153 || yy2arr153 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricCurrentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym162 := z.DecBinary()
	_ = yym162
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct163 := r.ContainerType()
		if yyct163 == codecSelferValueTypeMap1234 {
			yyl163 := r.ReadMapStart()
			if yyl163 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl163, d)
			}
		} else if yyct163 == codecSelferValueTypeArray1234 {
			yyl163 := r.ReadArrayStart()
			if yyl163 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl163, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys164Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys164Slc
	var yyhl164 bool = l >= 0
	for yyj164 := 0; ; yyj164++ {
		if yyhl164 {
			if yyj164 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys164Slc = r.DecodeBytes(yys164Slc, true, true)
		yys164 := string(yys164Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys164 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.CurrentValue = pkg4_resource.Quantity{}
			} else {
				yyv166 := &x.CurrentValue
				yym167 := z.DecBinary()
				_ = yym167
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv166) {
				} else if !yym167 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv166)
				} else {
					z.DecFallback(yyv166, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys164)
		} // end switch yys164
	} // end for yyj164
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj168 int
	var yyb168 bool
	var yyhl168 bool = l >= 0
	yyj168++
	if yyhl168 {
		yyb168 = yyj168 > l
	} else {
		yyb168 = r.CheckBreak()
	}
	if yyb168 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj168++
	if yyhl168 {
		yyb168 = yyj168 > l
	} else {
		yyb168 = r.CheckBreak()
	}
	if yyb168 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentValue = pkg4_resource.Quantity{}
	} else {
		yyv170 := &x.CurrentValue
		yym171 := z.DecBinary()
		_ = yym171
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv170) {
		} else if !yym171 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv170)
		} else {
			z.DecFallback(yyv170, false)
		}
	}
	for {
		yyj168++
		if yyhl168 {
			yyb168 = yyj168 > l
		} else {
			yyb168 = r.CheckBreak()
		}
		if yyb168 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj168-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *CustomMetricCurrentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym172 := z.EncBinary()
		_ = yym172
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep173 := !z.EncBinary()
			yy2arr173 := z.EncBasicHandle().StructToArray
			var yyq173 [1]bool
			_, _, _ = yysep173, yyq173, yy2arr173
			const yyr173 bool = false
			var yynn173 int
			if yyr173 || yy2arr173 {
				r.EncodeArrayStart(1)
			} else {
				yynn173 = 1
				for _, b := range yyq173 {
					if b {
						yynn173++
					}
				}
				r.EncodeMapStart(yynn173)
				yynn173 = 0
			}
			if yyr173 || yy2arr173 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym175 := z.EncBinary()
					_ = yym175
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym176 := z.EncBinary()
					_ = yym176
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			}
			if yyr173 || yy2arr173 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *CustomMetricCurrentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym177 := z.DecBinary()
	_ = yym177
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct178 := r.ContainerType()
		if yyct178 == codecSelferValueTypeMap1234 {
			yyl178 := r.ReadMapStart()
			if yyl178 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl178, d)
			}
		} else if yyct178 == codecSelferValueTypeArray1234 {
			yyl178 := r.ReadArrayStart()
			if yyl178 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl178, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys179Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys179Slc
	var yyhl179 bool = l >= 0
	for yyj179 := 0; ; yyj179++ {
		if yyhl179 {
			if yyj179 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys179Slc = r.DecodeBytes(yys179Slc, true, true)
		yys179 := string(yys179Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys179 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv180 := &x.Items
				yym181 := z.DecBinary()
				_ = yym181
				if false {
				} else {
					h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv180), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys179)
		} // end switch yys179
	} // end for yyj179
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *CustomMetricCurrentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj182 int
	var yyb182 bool
	var yyhl182 bool = l >= 0
	yyj182++
	if yyhl182 {
		yyb182 = yyj182 > l
	} else {
		yyb182 = r.CheckBreak()
	}
	if yyb182 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv183 := &x.Items
		yym184 := z.DecBinary()
		_ = yym184
		if false {
		} else {
			h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv183), d)
		}
	}
	for {
		yyj182++
		if yyhl182 {
			yyb182 = yyj182 > l
		} else {
			yyb182 = r.CheckBreak()
		}
		if yyb182 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj182-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym185 := z.EncBinary()
		_ = yym185
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep186 := !z.EncBinary()
			yy2arr186 := z.EncBasicHandle().StructToArray
			var yyq186 [4]bool
			_, _, _ = yysep186, yyq186, yy2arr186
			const yyr186 bool = false
			yyq186[1] = x.MinReplicas != nil
			yyq186[3] = x.CPUUtilization != nil
			var yynn186 int
			if yyr186 || yy2arr186 {
				r.EncodeArrayStart(4)
			} else {
				yynn186 = 2
				for _, b := range yyq186 {
					if b {
						yynn186++
					}
				}
				r.EncodeMapStart(yynn186)
				yynn186 = 0
			}
			if yyr186 || yy2arr186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy188 := &x.ScaleRef
				yy188.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("scaleRef"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy189 := &x.ScaleRef
				yy189.CodecEncodeSelf(e)
			}
			if yyr186 || yy2arr186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq186[1] {
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy191 := *x.MinReplicas
						yym192 := z.EncBinary()
						_ = yym192
						if false {
						} else {
							r.EncodeInt(int64(yy191))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq186[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MinReplicas == nil {
						r.EncodeNil()
					} else {
						yy193 := *x.MinReplicas
						yym194 := z.EncBinary()
						_ = yym194
						if false {
						} else {
							r.EncodeInt(int64(yy193))
						}
					}
				}
			}
			if yyr186 || yy2arr186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym196 := z.EncBinary()
				_ = yym196
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("maxReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym197 := z.EncBinary()
				_ = yym197
				if false {
				} else {
					r.EncodeInt(int64(x.MaxReplicas))
				}
			}
			if yyr186 || yy2arr186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq186[3] {
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq186[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("cpuUtilization"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CPUUtilization == nil {
						r.EncodeNil()
					} else {
						x.CPUUtilization.CodecEncodeSelf(e)
					}
				}
			}
			if yyr186 || yy2arr186 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym199 := z.DecBinary()
	_ = yym199
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct200 := r.ContainerType()
		if yyct200 == codecSelferValueTypeMap1234 {
			yyl200 := r.ReadMapStart()
			if yyl200 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl200, d)
			}
		} else if yyct200 == codecSelferValueTypeArray1234 {
			yyl200 := r.ReadArrayStart()
			if yyl200 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl200, 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 yys201Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys201Slc
	var yyhl201 bool = l >= 0
	for yyj201 := 0; ; yyj201++ {
		if yyhl201 {
			if yyj201 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys201Slc = r.DecodeBytes(yys201Slc, true, true)
		yys201 := string(yys201Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys201 {
		case "scaleRef":
			if r.TryDecodeAsNil() {
				x.ScaleRef = SubresourceReference{}
			} else {
				yyv202 := &x.ScaleRef
				yyv202.CodecDecodeSelf(d)
			}
		case "minReplicas":
			if r.TryDecodeAsNil() {
				if x.MinReplicas != nil {
					x.MinReplicas = nil
				}
			} else {
				if x.MinReplicas == nil {
					x.MinReplicas = new(int32)
				}
				yym204 := z.DecBinary()
				_ = yym204
				if false {
				} else {
					*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
				}
			}
		case "maxReplicas":
			if r.TryDecodeAsNil() {
				x.MaxReplicas = 0
			} else {
				x.MaxReplicas = int32(r.DecodeInt(32))
			}
		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, yys201)
		} // end switch yys201
	} // end for yyj201
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj207 int
	var yyb207 bool
	var yyhl207 bool = l >= 0
	yyj207++
	if yyhl207 {
		yyb207 = yyj207 > l
	} else {
		yyb207 = r.CheckBreak()
	}
	if yyb207 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ScaleRef = SubresourceReference{}
	} else {
		yyv208 := &x.ScaleRef
		yyv208.CodecDecodeSelf(d)
	}
	yyj207++
	if yyhl207 {
		yyb207 = yyj207 > l
	} else {
		yyb207 = r.CheckBreak()
	}
	if yyb207 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MinReplicas != nil {
			x.MinReplicas = nil
		}
	} else {
		if x.MinReplicas == nil {
			x.MinReplicas = new(int32)
		}
		yym210 := z.DecBinary()
		_ = yym210
		if false {
		} else {
			*((*int32)(x.MinReplicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj207++
	if yyhl207 {
		yyb207 = yyj207 > l
	} else {
		yyb207 = r.CheckBreak()
	}
	if yyb207 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxReplicas = 0
	} else {
		x.MaxReplicas = int32(r.DecodeInt(32))
	}
	yyj207++
	if yyhl207 {
		yyb207 = yyj207 > l
	} else {
		yyb207 = r.CheckBreak()
	}
	if yyb207 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CPUUtilization != nil {
			x.CPUUtilization = nil
		}
	} else {
		if x.CPUUtilization == nil {
			x.CPUUtilization = new(CPUTargetUtilization)
		}
		x.CPUUtilization.CodecDecodeSelf(d)
	}
	for {
		yyj207++
		if yyhl207 {
			yyb207 = yyj207 > l
		} else {
			yyb207 = r.CheckBreak()
		}
		if yyb207 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj207-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym213 := z.EncBinary()
		_ = yym213
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep214 := !z.EncBinary()
			yy2arr214 := z.EncBasicHandle().StructToArray
			var yyq214 [5]bool
			_, _, _ = yysep214, yyq214, yy2arr214
			const yyr214 bool = false
			yyq214[0] = x.ObservedGeneration != nil
			yyq214[1] = x.LastScaleTime != nil
			yyq214[4] = x.CurrentCPUUtilizationPercentage != nil
			var yynn214 int
			if yyr214 || yy2arr214 {
				r.EncodeArrayStart(5)
			} else {
				yynn214 = 2
				for _, b := range yyq214 {
					if b {
						yynn214++
					}
				}
				r.EncodeMapStart(yynn214)
				yynn214 = 0
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq214[0] {
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy216 := *x.ObservedGeneration
						yym217 := z.EncBinary()
						_ = yym217
						if false {
						} else {
							r.EncodeInt(int64(yy216))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq214[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ObservedGeneration == nil {
						r.EncodeNil()
					} else {
						yy218 := *x.ObservedGeneration
						yym219 := z.EncBinary()
						_ = yym219
						if false {
						} else {
							r.EncodeInt(int64(yy218))
						}
					}
				}
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq214[1] {
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym221 := z.EncBinary()
						_ = yym221
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym221 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym221 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq214[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastScaleTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.LastScaleTime == nil {
						r.EncodeNil()
					} else {
						yym222 := z.EncBinary()
						_ = yym222
						if false {
						} else if z.HasExtensions() && z.EncExt(x.LastScaleTime) {
						} else if yym222 {
							z.EncBinaryMarshal(x.LastScaleTime)
						} else if !yym222 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.LastScaleTime)
						} else {
							z.EncFallback(x.LastScaleTime)
						}
					}
				}
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym224 := z.EncBinary()
				_ = yym224
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym225 := z.EncBinary()
				_ = yym225
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentReplicas))
				}
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym227 := z.EncBinary()
				_ = yym227
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredReplicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym228 := z.EncBinary()
				_ = yym228
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredReplicas))
				}
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq214[4] {
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy230 := *x.CurrentCPUUtilizationPercentage
						yym231 := z.EncBinary()
						_ = yym231
						if false {
						} else {
							r.EncodeInt(int64(yy230))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq214[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("currentCPUUtilizationPercentage"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CurrentCPUUtilizationPercentage == nil {
						r.EncodeNil()
					} else {
						yy232 := *x.CurrentCPUUtilizationPercentage
						yym233 := z.EncBinary()
						_ = yym233
						if false {
						} else {
							r.EncodeInt(int64(yy232))
						}
					}
				}
			}
			if yyr214 || yy2arr214 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym234 := z.DecBinary()
	_ = yym234
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct235 := r.ContainerType()
		if yyct235 == codecSelferValueTypeMap1234 {
			yyl235 := r.ReadMapStart()
			if yyl235 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl235, d)
			}
		} else if yyct235 == codecSelferValueTypeArray1234 {
			yyl235 := r.ReadArrayStart()
			if yyl235 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl235, 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 yys236Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys236Slc
	var yyhl236 bool = l >= 0
	for yyj236 := 0; ; yyj236++ {
		if yyhl236 {
			if yyj236 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys236Slc = r.DecodeBytes(yys236Slc, true, true)
		yys236 := string(yys236Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys236 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				if x.ObservedGeneration != nil {
					x.ObservedGeneration = nil
				}
			} else {
				if x.ObservedGeneration == nil {
					x.ObservedGeneration = new(int64)
				}
				yym238 := z.DecBinary()
				_ = yym238
				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)
				}
				yym240 := z.DecBinary()
				_ = yym240
				if false {
				} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
				} else if yym240 {
					z.DecBinaryUnmarshal(x.LastScaleTime)
				} else if !yym240 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.LastScaleTime)
				} else {
					z.DecFallback(x.LastScaleTime, false)
				}
			}
		case "currentReplicas":
			if r.TryDecodeAsNil() {
				x.CurrentReplicas = 0
			} else {
				x.CurrentReplicas = int32(r.DecodeInt(32))
			}
		case "desiredReplicas":
			if r.TryDecodeAsNil() {
				x.DesiredReplicas = 0
			} else {
				x.DesiredReplicas = int32(r.DecodeInt(32))
			}
		case "currentCPUUtilizationPercentage":
			if r.TryDecodeAsNil() {
				if x.CurrentCPUUtilizationPercentage != nil {
					x.CurrentCPUUtilizationPercentage = nil
				}
			} else {
				if x.CurrentCPUUtilizationPercentage == nil {
					x.CurrentCPUUtilizationPercentage = new(int32)
				}
				yym244 := z.DecBinary()
				_ = yym244
				if false {
				} else {
					*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys236)
		} // end switch yys236
	} // end for yyj236
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj245 int
	var yyb245 bool
	var yyhl245 bool = l >= 0
	yyj245++
	if yyhl245 {
		yyb245 = yyj245 > l
	} else {
		yyb245 = r.CheckBreak()
	}
	if yyb245 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ObservedGeneration != nil {
			x.ObservedGeneration = nil
		}
	} else {
		if x.ObservedGeneration == nil {
			x.ObservedGeneration = new(int64)
		}
		yym247 := z.DecBinary()
		_ = yym247
		if false {
		} else {
			*((*int64)(x.ObservedGeneration)) = int64(r.DecodeInt(64))
		}
	}
	yyj245++
	if yyhl245 {
		yyb245 = yyj245 > l
	} else {
		yyb245 = r.CheckBreak()
	}
	if yyb245 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.LastScaleTime != nil {
			x.LastScaleTime = nil
		}
	} else {
		if x.LastScaleTime == nil {
			x.LastScaleTime = new(pkg1_unversioned.Time)
		}
		yym249 := z.DecBinary()
		_ = yym249
		if false {
		} else if z.HasExtensions() && z.DecExt(x.LastScaleTime) {
		} else if yym249 {
			z.DecBinaryUnmarshal(x.LastScaleTime)
		} else if !yym249 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.LastScaleTime)
		} else {
			z.DecFallback(x.LastScaleTime, false)
		}
	}
	yyj245++
	if yyhl245 {
		yyb245 = yyj245 > l
	} else {
		yyb245 = r.CheckBreak()
	}
	if yyb245 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentReplicas = 0
	} else {
		x.CurrentReplicas = int32(r.DecodeInt(32))
	}
	yyj245++
	if yyhl245 {
		yyb245 = yyj245 > l
	} else {
		yyb245 = r.CheckBreak()
	}
	if yyb245 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredReplicas = 0
	} else {
		x.DesiredReplicas = int32(r.DecodeInt(32))
	}
	yyj245++
	if yyhl245 {
		yyb245 = yyj245 > l
	} else {
		yyb245 = r.CheckBreak()
	}
	if yyb245 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CurrentCPUUtilizationPercentage != nil {
			x.CurrentCPUUtilizationPercentage = nil
		}
	} else {
		if x.CurrentCPUUtilizationPercentage == nil {
			x.CurrentCPUUtilizationPercentage = new(int32)
		}
		yym253 := z.DecBinary()
		_ = yym253
		if false {
		} else {
			*((*int32)(x.CurrentCPUUtilizationPercentage)) = int32(r.DecodeInt(32))
		}
	}
	for {
		yyj245++
		if yyhl245 {
			yyb245 = yyj245 > l
		} else {
			yyb245 = r.CheckBreak()
		}
		if yyb245 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj245-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscaler) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym254 := z.EncBinary()
		_ = yym254
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep255 := !z.EncBinary()
			yy2arr255 := z.EncBasicHandle().StructToArray
			var yyq255 [5]bool
			_, _, _ = yysep255, yyq255, yy2arr255
			const yyr255 bool = false
			yyq255[0] = x.Kind != ""
			yyq255[1] = x.APIVersion != ""
			yyq255[2] = true
			yyq255[3] = true
			yyq255[4] = true
			var yynn255 int
			if yyr255 || yy2arr255 {
				r.EncodeArrayStart(5)
			} else {
				yynn255 = 0
				for _, b := range yyq255 {
					if b {
						yynn255++
					}
				}
				r.EncodeMapStart(yynn255)
				yynn255 = 0
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[0] {
					yym257 := z.EncBinary()
					_ = yym257
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq255[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym258 := z.EncBinary()
					_ = yym258
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[1] {
					yym260 := z.EncBinary()
					_ = yym260
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq255[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym261 := z.EncBinary()
					_ = yym261
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[2] {
					yy263 := &x.ObjectMeta
					yy263.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq255[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy264 := &x.ObjectMeta
					yy264.CodecEncodeSelf(e)
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[3] {
					yy266 := &x.Spec
					yy266.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq255[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy267 := &x.Spec
					yy267.CodecEncodeSelf(e)
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq255[4] {
					yy269 := &x.Status
					yy269.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq255[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy270 := &x.Status
					yy270.CodecEncodeSelf(e)
				}
			}
			if yyr255 || yy2arr255 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscaler) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym271 := z.DecBinary()
	_ = yym271
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct272 := r.ContainerType()
		if yyct272 == codecSelferValueTypeMap1234 {
			yyl272 := r.ReadMapStart()
			if yyl272 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl272, d)
			}
		} else if yyct272 == codecSelferValueTypeArray1234 {
			yyl272 := r.ReadArrayStart()
			if yyl272 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl272, 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 yys273Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys273Slc
	var yyhl273 bool = l >= 0
	for yyj273 := 0; ; yyj273++ {
		if yyhl273 {
			if yyj273 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys273Slc = r.DecodeBytes(yys273Slc, true, true)
		yys273 := string(yys273Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys273 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv276 := &x.ObjectMeta
				yyv276.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = HorizontalPodAutoscalerSpec{}
			} else {
				yyv277 := &x.Spec
				yyv277.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = HorizontalPodAutoscalerStatus{}
			} else {
				yyv278 := &x.Status
				yyv278.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys273)
		} // end switch yys273
	} // end for yyj273
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscaler) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj279 int
	var yyb279 bool
	var yyhl279 bool = l >= 0
	yyj279++
	if yyhl279 {
		yyb279 = yyj279 > l
	} else {
		yyb279 = r.CheckBreak()
	}
	if yyb279 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj279++
	if yyhl279 {
		yyb279 = yyj279 > l
	} else {
		yyb279 = r.CheckBreak()
	}
	if yyb279 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj279++
	if yyhl279 {
		yyb279 = yyj279 > l
	} else {
		yyb279 = r.CheckBreak()
	}
	if yyb279 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv282 := &x.ObjectMeta
		yyv282.CodecDecodeSelf(d)
	}
	yyj279++
	if yyhl279 {
		yyb279 = yyj279 > l
	} else {
		yyb279 = r.CheckBreak()
	}
	if yyb279 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = HorizontalPodAutoscalerSpec{}
	} else {
		yyv283 := &x.Spec
		yyv283.CodecDecodeSelf(d)
	}
	yyj279++
	if yyhl279 {
		yyb279 = yyj279 > l
	} else {
		yyb279 = r.CheckBreak()
	}
	if yyb279 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = HorizontalPodAutoscalerStatus{}
	} else {
		yyv284 := &x.Status
		yyv284.CodecDecodeSelf(d)
	}
	for {
		yyj279++
		if yyhl279 {
			yyb279 = yyj279 > l
		} else {
			yyb279 = r.CheckBreak()
		}
		if yyb279 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj279-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HorizontalPodAutoscalerList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym285 := z.EncBinary()
		_ = yym285
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep286 := !z.EncBinary()
			yy2arr286 := z.EncBasicHandle().StructToArray
			var yyq286 [4]bool
			_, _, _ = yysep286, yyq286, yy2arr286
			const yyr286 bool = false
			yyq286[0] = x.Kind != ""
			yyq286[1] = x.APIVersion != ""
			yyq286[2] = true
			var yynn286 int
			if yyr286 || yy2arr286 {
				r.EncodeArrayStart(4)
			} else {
				yynn286 = 1
				for _, b := range yyq286 {
					if b {
						yynn286++
					}
				}
				r.EncodeMapStart(yynn286)
				yynn286 = 0
			}
			if yyr286 || yy2arr286 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq286[0] {
					yym288 := z.EncBinary()
					_ = yym288
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq286[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym289 := z.EncBinary()
					_ = yym289
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr286 || yy2arr286 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq286[1] {
					yym291 := z.EncBinary()
					_ = yym291
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq286[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym292 := z.EncBinary()
					_ = yym292
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr286 || yy2arr286 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq286[2] {
					yy294 := &x.ListMeta
					yym295 := z.EncBinary()
					_ = yym295
					if false {
					} else if z.HasExtensions() && z.EncExt(yy294) {
					} else {
						z.EncFallback(yy294)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq286[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy296 := &x.ListMeta
					yym297 := z.EncBinary()
					_ = yym297
					if false {
					} else if z.HasExtensions() && z.EncExt(yy296) {
					} else {
						z.EncFallback(yy296)
					}
				}
			}
			if yyr286 || yy2arr286 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym299 := z.EncBinary()
					_ = yym299
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym300 := z.EncBinary()
					_ = yym300
					if false {
					} else {
						h.encSliceHorizontalPodAutoscaler(([]HorizontalPodAutoscaler)(x.Items), e)
					}
				}
			}
			if yyr286 || yy2arr286 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HorizontalPodAutoscalerList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym301 := z.DecBinary()
	_ = yym301
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct302 := r.ContainerType()
		if yyct302 == codecSelferValueTypeMap1234 {
			yyl302 := r.ReadMapStart()
			if yyl302 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl302, d)
			}
		} else if yyct302 == codecSelferValueTypeArray1234 {
			yyl302 := r.ReadArrayStart()
			if yyl302 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl302, 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 yys303Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys303Slc
	var yyhl303 bool = l >= 0
	for yyj303 := 0; ; yyj303++ {
		if yyhl303 {
			if yyj303 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys303Slc = r.DecodeBytes(yys303Slc, true, true)
		yys303 := string(yys303Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys303 {
		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 {
				yyv306 := &x.ListMeta
				yym307 := z.DecBinary()
				_ = yym307
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv306) {
				} else {
					z.DecFallback(yyv306, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv308 := &x.Items
				yym309 := z.DecBinary()
				_ = yym309
				if false {
				} else {
					h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv308), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys303)
		} // end switch yys303
	} // end for yyj303
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HorizontalPodAutoscalerList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj310 int
	var yyb310 bool
	var yyhl310 bool = l >= 0
	yyj310++
	if yyhl310 {
		yyb310 = yyj310 > l
	} else {
		yyb310 = r.CheckBreak()
	}
	if yyb310 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj310++
	if yyhl310 {
		yyb310 = yyj310 > l
	} else {
		yyb310 = r.CheckBreak()
	}
	if yyb310 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj310++
	if yyhl310 {
		yyb310 = yyj310 > l
	} else {
		yyb310 = r.CheckBreak()
	}
	if yyb310 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv313 := &x.ListMeta
		yym314 := z.DecBinary()
		_ = yym314
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv313) {
		} else {
			z.DecFallback(yyv313, false)
		}
	}
	yyj310++
	if yyhl310 {
		yyb310 = yyj310 > l
	} else {
		yyb310 = r.CheckBreak()
	}
	if yyb310 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv315 := &x.Items
		yym316 := z.DecBinary()
		_ = yym316
		if false {
		} else {
			h.decSliceHorizontalPodAutoscaler((*[]HorizontalPodAutoscaler)(yyv315), d)
		}
	}
	for {
		yyj310++
		if yyhl310 {
			yyb310 = yyj310 > l
		} else {
			yyb310 = r.CheckBreak()
		}
		if yyb310 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj310-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResource) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym317 := z.EncBinary()
		_ = yym317
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep318 := !z.EncBinary()
			yy2arr318 := z.EncBasicHandle().StructToArray
			var yyq318 [5]bool
			_, _, _ = yysep318, yyq318, yy2arr318
			const yyr318 bool = false
			yyq318[0] = x.Kind != ""
			yyq318[1] = x.APIVersion != ""
			yyq318[2] = true
			yyq318[3] = x.Description != ""
			yyq318[4] = len(x.Versions) != 0
			var yynn318 int
			if yyr318 || yy2arr318 {
				r.EncodeArrayStart(5)
			} else {
				yynn318 = 0
				for _, b := range yyq318 {
					if b {
						yynn318++
					}
				}
				r.EncodeMapStart(yynn318)
				yynn318 = 0
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq318[0] {
					yym320 := z.EncBinary()
					_ = yym320
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq318[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym321 := z.EncBinary()
					_ = yym321
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq318[1] {
					yym323 := z.EncBinary()
					_ = yym323
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq318[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym324 := z.EncBinary()
					_ = yym324
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq318[2] {
					yy326 := &x.ObjectMeta
					yy326.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq318[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy327 := &x.ObjectMeta
					yy327.CodecEncodeSelf(e)
				}
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq318[3] {
					yym329 := z.EncBinary()
					_ = yym329
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq318[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym330 := z.EncBinary()
					_ = yym330
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq318[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym332 := z.EncBinary()
						_ = yym332
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq318[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym333 := z.EncBinary()
						_ = yym333
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yyr318 || yy2arr318 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResource) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym334 := z.DecBinary()
	_ = yym334
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct335 := r.ContainerType()
		if yyct335 == codecSelferValueTypeMap1234 {
			yyl335 := r.ReadMapStart()
			if yyl335 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl335, d)
			}
		} else if yyct335 == codecSelferValueTypeArray1234 {
			yyl335 := r.ReadArrayStart()
			if yyl335 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl335, 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 yys336Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys336Slc
	var yyhl336 bool = l >= 0
	for yyj336 := 0; ; yyj336++ {
		if yyhl336 {
			if yyj336 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys336Slc = r.DecodeBytes(yys336Slc, true, true)
		yys336 := string(yys336Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys336 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv339 := &x.ObjectMeta
				yyv339.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv341 := &x.Versions
				yym342 := z.DecBinary()
				_ = yym342
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv341), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys336)
		} // end switch yys336
	} // end for yyj336
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj343 int
	var yyb343 bool
	var yyhl343 bool = l >= 0
	yyj343++
	if yyhl343 {
		yyb343 = yyj343 > l
	} else {
		yyb343 = r.CheckBreak()
	}
	if yyb343 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj343++
	if yyhl343 {
		yyb343 = yyj343 > l
	} else {
		yyb343 = r.CheckBreak()
	}
	if yyb343 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj343++
	if yyhl343 {
		yyb343 = yyj343 > l
	} else {
		yyb343 = r.CheckBreak()
	}
	if yyb343 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv346 := &x.ObjectMeta
		yyv346.CodecDecodeSelf(d)
	}
	yyj343++
	if yyhl343 {
		yyb343 = yyj343 > l
	} else {
		yyb343 = r.CheckBreak()
	}
	if yyb343 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj343++
	if yyhl343 {
		yyb343 = yyj343 > l
	} else {
		yyb343 = r.CheckBreak()
	}
	if yyb343 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv348 := &x.Versions
		yym349 := z.DecBinary()
		_ = yym349
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv348), d)
		}
	}
	for {
		yyj343++
		if yyhl343 {
			yyb343 = yyj343 > l
		} else {
			yyb343 = r.CheckBreak()
		}
		if yyb343 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj343-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym350 := z.EncBinary()
		_ = yym350
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep351 := !z.EncBinary()
			yy2arr351 := z.EncBasicHandle().StructToArray
			var yyq351 [4]bool
			_, _, _ = yysep351, yyq351, yy2arr351
			const yyr351 bool = false
			yyq351[0] = x.Kind != ""
			yyq351[1] = x.APIVersion != ""
			yyq351[2] = true
			var yynn351 int
			if yyr351 || yy2arr351 {
				r.EncodeArrayStart(4)
			} else {
				yynn351 = 1
				for _, b := range yyq351 {
					if b {
						yynn351++
					}
				}
				r.EncodeMapStart(yynn351)
				yynn351 = 0
			}
			if yyr351 || yy2arr351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq351[0] {
					yym353 := z.EncBinary()
					_ = yym353
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq351[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym354 := z.EncBinary()
					_ = yym354
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr351 || yy2arr351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq351[1] {
					yym356 := z.EncBinary()
					_ = yym356
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq351[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym357 := z.EncBinary()
					_ = yym357
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr351 || yy2arr351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq351[2] {
					yy359 := &x.ListMeta
					yym360 := z.EncBinary()
					_ = yym360
					if false {
					} else if z.HasExtensions() && z.EncExt(yy359) {
					} else {
						z.EncFallback(yy359)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq351[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy361 := &x.ListMeta
					yym362 := z.EncBinary()
					_ = yym362
					if false {
					} else if z.HasExtensions() && z.EncExt(yy361) {
					} else {
						z.EncFallback(yy361)
					}
				}
			}
			if yyr351 || yy2arr351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym364 := z.EncBinary()
					_ = yym364
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym365 := z.EncBinary()
					_ = yym365
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yyr351 || yy2arr351 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym366 := z.DecBinary()
	_ = yym366
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct367 := r.ContainerType()
		if yyct367 == codecSelferValueTypeMap1234 {
			yyl367 := r.ReadMapStart()
			if yyl367 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl367, d)
			}
		} else if yyct367 == codecSelferValueTypeArray1234 {
			yyl367 := r.ReadArrayStart()
			if yyl367 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl367, 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 yys368Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys368Slc
	var yyhl368 bool = l >= 0
	for yyj368 := 0; ; yyj368++ {
		if yyhl368 {
			if yyj368 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys368Slc = r.DecodeBytes(yys368Slc, true, true)
		yys368 := string(yys368Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys368 {
		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 {
				yyv371 := &x.ListMeta
				yym372 := z.DecBinary()
				_ = yym372
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv371) {
				} else {
					z.DecFallback(yyv371, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv373 := &x.Items
				yym374 := z.DecBinary()
				_ = yym374
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv373), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys368)
		} // end switch yys368
	} // end for yyj368
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj375 int
	var yyb375 bool
	var yyhl375 bool = l >= 0
	yyj375++
	if yyhl375 {
		yyb375 = yyj375 > l
	} else {
		yyb375 = r.CheckBreak()
	}
	if yyb375 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj375++
	if yyhl375 {
		yyb375 = yyj375 > l
	} else {
		yyb375 = r.CheckBreak()
	}
	if yyb375 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj375++
	if yyhl375 {
		yyb375 = yyj375 > l
	} else {
		yyb375 = r.CheckBreak()
	}
	if yyb375 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv378 := &x.ListMeta
		yym379 := z.DecBinary()
		_ = yym379
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv378) {
		} else {
			z.DecFallback(yyv378, false)
		}
	}
	yyj375++
	if yyhl375 {
		yyb375 = yyj375 > l
	} else {
		yyb375 = r.CheckBreak()
	}
	if yyb375 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv380 := &x.Items
		yym381 := z.DecBinary()
		_ = yym381
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv380), d)
		}
	}
	for {
		yyj375++
		if yyhl375 {
			yyb375 = yyj375 > l
		} else {
			yyb375 = r.CheckBreak()
		}
		if yyb375 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj375-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *APIVersion) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym382 := z.EncBinary()
		_ = yym382
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep383 := !z.EncBinary()
			yy2arr383 := z.EncBasicHandle().StructToArray
			var yyq383 [1]bool
			_, _, _ = yysep383, yyq383, yy2arr383
			const yyr383 bool = false
			yyq383[0] = x.Name != ""
			var yynn383 int
			if yyr383 || yy2arr383 {
				r.EncodeArrayStart(1)
			} else {
				yynn383 = 0
				for _, b := range yyq383 {
					if b {
						yynn383++
					}
				}
				r.EncodeMapStart(yynn383)
				yynn383 = 0
			}
			if yyr383 || yy2arr383 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq383[0] {
					yym385 := z.EncBinary()
					_ = yym385
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq383[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym386 := z.EncBinary()
					_ = yym386
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr383 || yy2arr383 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *APIVersion) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym387 := z.DecBinary()
	_ = yym387
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct388 := r.ContainerType()
		if yyct388 == codecSelferValueTypeMap1234 {
			yyl388 := r.ReadMapStart()
			if yyl388 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl388, d)
			}
		} else if yyct388 == codecSelferValueTypeArray1234 {
			yyl388 := r.ReadArrayStart()
			if yyl388 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl388, 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 yys389Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys389Slc
	var yyhl389 bool = l >= 0
	for yyj389 := 0; ; yyj389++ {
		if yyhl389 {
			if yyj389 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys389Slc = r.DecodeBytes(yys389Slc, true, true)
		yys389 := string(yys389Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys389 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys389)
		} // end switch yys389
	} // end for yyj389
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *APIVersion) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj391 int
	var yyb391 bool
	var yyhl391 bool = l >= 0
	yyj391++
	if yyhl391 {
		yyb391 = yyj391 > l
	} else {
		yyb391 = r.CheckBreak()
	}
	if yyb391 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	for {
		yyj391++
		if yyhl391 {
			yyb391 = yyj391 > l
		} else {
			yyb391 = r.CheckBreak()
		}
		if yyb391 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj391-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceData) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym393 := z.EncBinary()
		_ = yym393
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep394 := !z.EncBinary()
			yy2arr394 := z.EncBasicHandle().StructToArray
			var yyq394 [4]bool
			_, _, _ = yysep394, yyq394, yy2arr394
			const yyr394 bool = false
			yyq394[0] = x.Kind != ""
			yyq394[1] = x.APIVersion != ""
			yyq394[2] = true
			yyq394[3] = len(x.Data) != 0
			var yynn394 int
			if yyr394 || yy2arr394 {
				r.EncodeArrayStart(4)
			} else {
				yynn394 = 0
				for _, b := range yyq394 {
					if b {
						yynn394++
					}
				}
				r.EncodeMapStart(yynn394)
				yynn394 = 0
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[0] {
					yym396 := z.EncBinary()
					_ = yym396
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq394[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym397 := z.EncBinary()
					_ = yym397
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[1] {
					yym399 := z.EncBinary()
					_ = yym399
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq394[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym400 := z.EncBinary()
					_ = yym400
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[2] {
					yy402 := &x.ObjectMeta
					yy402.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq394[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy403 := &x.ObjectMeta
					yy403.CodecEncodeSelf(e)
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq394[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym405 := z.EncBinary()
						_ = yym405
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq394[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym406 := z.EncBinary()
						_ = yym406
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yyr394 || yy2arr394 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceData) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym407 := z.DecBinary()
	_ = yym407
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct408 := r.ContainerType()
		if yyct408 == codecSelferValueTypeMap1234 {
			yyl408 := r.ReadMapStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl408, d)
			}
		} else if yyct408 == codecSelferValueTypeArray1234 {
			yyl408 := r.ReadArrayStart()
			if yyl408 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl408, 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 yys409Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys409Slc
	var yyhl409 bool = l >= 0
	for yyj409 := 0; ; yyj409++ {
		if yyhl409 {
			if yyj409 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys409Slc = r.DecodeBytes(yys409Slc, true, true)
		yys409 := string(yys409Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys409 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv412 := &x.ObjectMeta
				yyv412.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv413 := &x.Data
				yym414 := z.DecBinary()
				_ = yym414
				if false {
				} else {
					*yyv413 = r.DecodeBytes(*(*[]byte)(yyv413), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys409)
		} // end switch yys409
	} // end for yyj409
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceData) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj415 int
	var yyb415 bool
	var yyhl415 bool = l >= 0
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv418 := &x.ObjectMeta
		yyv418.CodecDecodeSelf(d)
	}
	yyj415++
	if yyhl415 {
		yyb415 = yyj415 > l
	} else {
		yyb415 = r.CheckBreak()
	}
	if yyb415 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv419 := &x.Data
		yym420 := z.DecBinary()
		_ = yym420
		if false {
		} else {
			*yyv419 = r.DecodeBytes(*(*[]byte)(yyv419), false, false)
		}
	}
	for {
		yyj415++
		if yyhl415 {
			yyb415 = yyj415 > l
		} else {
			yyb415 = r.CheckBreak()
		}
		if yyb415 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj415-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym421 := z.EncBinary()
		_ = yym421
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep422 := !z.EncBinary()
			yy2arr422 := z.EncBasicHandle().StructToArray
			var yyq422 [5]bool
			_, _, _ = yysep422, yyq422, yy2arr422
			const yyr422 bool = false
			yyq422[0] = x.Kind != ""
			yyq422[1] = x.APIVersion != ""
			yyq422[2] = true
			yyq422[3] = true
			yyq422[4] = true
			var yynn422 int
			if yyr422 || yy2arr422 {
				r.EncodeArrayStart(5)
			} else {
				yynn422 = 0
				for _, b := range yyq422 {
					if b {
						yynn422++
					}
				}
				r.EncodeMapStart(yynn422)
				yynn422 = 0
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[0] {
					yym424 := z.EncBinary()
					_ = yym424
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq422[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym425 := z.EncBinary()
					_ = yym425
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[1] {
					yym427 := z.EncBinary()
					_ = yym427
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq422[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym428 := z.EncBinary()
					_ = yym428
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[2] {
					yy430 := &x.ObjectMeta
					yy430.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy431 := &x.ObjectMeta
					yy431.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[3] {
					yy433 := &x.Spec
					yy433.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy434 := &x.Spec
					yy434.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq422[4] {
					yy436 := &x.Status
					yy436.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq422[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy437 := &x.Status
					yy437.CodecEncodeSelf(e)
				}
			}
			if yyr422 || yy2arr422 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym438 := z.DecBinary()
	_ = yym438
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct439 := r.ContainerType()
		if yyct439 == codecSelferValueTypeMap1234 {
			yyl439 := r.ReadMapStart()
			if yyl439 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl439, d)
			}
		} else if yyct439 == codecSelferValueTypeArray1234 {
			yyl439 := r.ReadArrayStart()
			if yyl439 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl439, 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 yys440Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys440Slc
	var yyhl440 bool = l >= 0
	for yyj440 := 0; ; yyj440++ {
		if yyhl440 {
			if yyj440 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys440Slc = r.DecodeBytes(yys440Slc, true, true)
		yys440 := string(yys440Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys440 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv443 := &x.ObjectMeta
				yyv443.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv444 := &x.Spec
				yyv444.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv445 := &x.Status
				yyv445.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys440)
		} // end switch yys440
	} // end for yyj440
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj446 int
	var yyb446 bool
	var yyhl446 bool = l >= 0
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv449 := &x.ObjectMeta
		yyv449.CodecDecodeSelf(d)
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv450 := &x.Spec
		yyv450.CodecDecodeSelf(d)
	}
	yyj446++
	if yyhl446 {
		yyb446 = yyj446 > l
	} else {
		yyb446 = r.CheckBreak()
	}
	if yyb446 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv451 := &x.Status
		yyv451.CodecDecodeSelf(d)
	}
	for {
		yyj446++
		if yyhl446 {
			yyb446 = yyj446 > l
		} else {
			yyb446 = r.CheckBreak()
		}
		if yyb446 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj446-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym452 := z.EncBinary()
		_ = yym452
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep453 := !z.EncBinary()
			yy2arr453 := z.EncBasicHandle().StructToArray
			var yyq453 [8]bool
			_, _, _ = yysep453, yyq453, yy2arr453
			const yyr453 bool = false
			yyq453[0] = x.Replicas != nil
			yyq453[1] = x.Selector != nil
			yyq453[3] = true
			yyq453[4] = x.MinReadySeconds != 0
			yyq453[5] = x.RevisionHistoryLimit != nil
			yyq453[6] = x.Paused != false
			yyq453[7] = x.RollbackTo != nil
			var yynn453 int
			if yyr453 || yy2arr453 {
				r.EncodeArrayStart(8)
			} else {
				yynn453 = 1
				for _, b := range yyq453 {
					if b {
						yynn453++
					}
				}
				r.EncodeMapStart(yynn453)
				yynn453 = 0
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy455 := *x.Replicas
						yym456 := z.EncBinary()
						_ = yym456
						if false {
						} else {
							r.EncodeInt(int64(yy455))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy457 := *x.Replicas
						yym458 := z.EncBinary()
						_ = yym458
						if false {
						} else {
							r.EncodeInt(int64(yy457))
						}
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy461 := &x.Template
				yy461.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy462 := &x.Template
				yy462.CodecEncodeSelf(e)
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[3] {
					yy464 := &x.Strategy
					yy464.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy465 := &x.Strategy
					yy465.CodecEncodeSelf(e)
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[4] {
					yym467 := z.EncBinary()
					_ = yym467
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq453[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym468 := z.EncBinary()
					_ = yym468
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[5] {
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy470 := *x.RevisionHistoryLimit
						yym471 := z.EncBinary()
						_ = yym471
						if false {
						} else {
							r.EncodeInt(int64(yy470))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy472 := *x.RevisionHistoryLimit
						yym473 := z.EncBinary()
						_ = yym473
						if false {
						} else {
							r.EncodeInt(int64(yy472))
						}
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[6] {
					yym475 := z.EncBinary()
					_ = yym475
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq453[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("paused"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym476 := z.EncBinary()
					_ = yym476
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq453[7] {
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq453[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				}
			}
			if yyr453 || yy2arr453 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym478 := z.DecBinary()
	_ = yym478
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct479 := r.ContainerType()
		if yyct479 == codecSelferValueTypeMap1234 {
			yyl479 := r.ReadMapStart()
			if yyl479 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl479, d)
			}
		} else if yyct479 == codecSelferValueTypeArray1234 {
			yyl479 := r.ReadArrayStart()
			if yyl479 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl479, 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 yys480Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys480Slc
	var yyhl480 bool = l >= 0
	for yyj480 := 0; ; yyj480++ {
		if yyhl480 {
			if yyj480 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys480Slc = r.DecodeBytes(yys480Slc, true, true)
		yys480 := string(yys480Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys480 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym482 := z.DecBinary()
				_ = yym482
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv484 := &x.Template
				yyv484.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv485 := &x.Strategy
				yyv485.CodecDecodeSelf(d)
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		case "revisionHistoryLimit":
			if r.TryDecodeAsNil() {
				if x.RevisionHistoryLimit != nil {
					x.RevisionHistoryLimit = nil
				}
			} else {
				if x.RevisionHistoryLimit == nil {
					x.RevisionHistoryLimit = new(int32)
				}
				yym488 := z.DecBinary()
				_ = yym488
				if false {
				} else {
					*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
				}
			}
		case "paused":
			if r.TryDecodeAsNil() {
				x.Paused = false
			} else {
				x.Paused = bool(r.DecodeBool())
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				if x.RollbackTo != nil {
					x.RollbackTo = nil
				}
			} else {
				if x.RollbackTo == nil {
					x.RollbackTo = new(RollbackConfig)
				}
				x.RollbackTo.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys480)
		} // end switch yys480
	} // end for yyj480
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj491 int
	var yyb491 bool
	var yyhl491 bool = l >= 0
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym493 := z.DecBinary()
		_ = yym493
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv495 := &x.Template
		yyv495.CodecDecodeSelf(d)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv496 := &x.Strategy
		yyv496.CodecDecodeSelf(d)
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RevisionHistoryLimit != nil {
			x.RevisionHistoryLimit = nil
		}
	} else {
		if x.RevisionHistoryLimit == nil {
			x.RevisionHistoryLimit = new(int32)
		}
		yym499 := z.DecBinary()
		_ = yym499
		if false {
		} else {
			*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
		}
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paused = false
	} else {
		x.Paused = bool(r.DecodeBool())
	}
	yyj491++
	if yyhl491 {
		yyb491 = yyj491 > l
	} else {
		yyb491 = r.CheckBreak()
	}
	if yyb491 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollbackTo != nil {
			x.RollbackTo = nil
		}
	} else {
		if x.RollbackTo == nil {
			x.RollbackTo = new(RollbackConfig)
		}
		x.RollbackTo.CodecDecodeSelf(d)
	}
	for {
		yyj491++
		if yyhl491 {
			yyb491 = yyj491 > l
		} else {
			yyb491 = r.CheckBreak()
		}
		if yyb491 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj491-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentRollback) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym502 := z.EncBinary()
		_ = yym502
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep503 := !z.EncBinary()
			yy2arr503 := z.EncBasicHandle().StructToArray
			var yyq503 [5]bool
			_, _, _ = yysep503, yyq503, yy2arr503
			const yyr503 bool = false
			yyq503[0] = x.Kind != ""
			yyq503[1] = x.APIVersion != ""
			yyq503[3] = len(x.UpdatedAnnotations) != 0
			var yynn503 int
			if yyr503 || yy2arr503 {
				r.EncodeArrayStart(5)
			} else {
				yynn503 = 2
				for _, b := range yyq503 {
					if b {
						yynn503++
					}
				}
				r.EncodeMapStart(yynn503)
				yynn503 = 0
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[0] {
					yym505 := z.EncBinary()
					_ = yym505
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq503[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym506 := z.EncBinary()
					_ = yym506
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[1] {
					yym508 := z.EncBinary()
					_ = yym508
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq503[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym509 := z.EncBinary()
					_ = yym509
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym511 := z.EncBinary()
				_ = yym511
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("name"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym512 := z.EncBinary()
				_ = yym512
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq503[3] {
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym514 := z.EncBinary()
						_ = yym514
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq503[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym515 := z.EncBinary()
						_ = yym515
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				}
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy517 := &x.RollbackTo
				yy517.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy518 := &x.RollbackTo
				yy518.CodecEncodeSelf(e)
			}
			if yyr503 || yy2arr503 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentRollback) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym519 := z.DecBinary()
	_ = yym519
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct520 := r.ContainerType()
		if yyct520 == codecSelferValueTypeMap1234 {
			yyl520 := r.ReadMapStart()
			if yyl520 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl520, d)
			}
		} else if yyct520 == codecSelferValueTypeArray1234 {
			yyl520 := r.ReadArrayStart()
			if yyl520 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl520, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *DeploymentRollback) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys521Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys521Slc
	var yyhl521 bool = l >= 0
	for yyj521 := 0; ; yyj521++ {
		if yyhl521 {
			if yyj521 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys521Slc = r.DecodeBytes(yys521Slc, true, true)
		yys521 := string(yys521Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys521 {
		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 "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "updatedAnnotations":
			if r.TryDecodeAsNil() {
				x.UpdatedAnnotations = nil
			} else {
				yyv525 := &x.UpdatedAnnotations
				yym526 := z.DecBinary()
				_ = yym526
				if false {
				} else {
					z.F.DecMapStringStringX(yyv525, false, d)
				}
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				x.RollbackTo = RollbackConfig{}
			} else {
				yyv527 := &x.RollbackTo
				yyv527.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys521)
		} // end switch yys521
	} // end for yyj521
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentRollback) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj528 int
	var yyb528 bool
	var yyhl528 bool = l >= 0
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedAnnotations = nil
	} else {
		yyv532 := &x.UpdatedAnnotations
		yym533 := z.DecBinary()
		_ = yym533
		if false {
		} else {
			z.F.DecMapStringStringX(yyv532, false, d)
		}
	}
	yyj528++
	if yyhl528 {
		yyb528 = yyj528 > l
	} else {
		yyb528 = r.CheckBreak()
	}
	if yyb528 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RollbackTo = RollbackConfig{}
	} else {
		yyv534 := &x.RollbackTo
		yyv534.CodecDecodeSelf(d)
	}
	for {
		yyj528++
		if yyhl528 {
			yyb528 = yyj528 > l
		} else {
			yyb528 = r.CheckBreak()
		}
		if yyb528 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj528-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *RollbackConfig) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym535 := z.EncBinary()
		_ = yym535
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep536 := !z.EncBinary()
			yy2arr536 := z.EncBasicHandle().StructToArray
			var yyq536 [1]bool
			_, _, _ = yysep536, yyq536, yy2arr536
			const yyr536 bool = false
			yyq536[0] = x.Revision != 0
			var yynn536 int
			if yyr536 || yy2arr536 {
				r.EncodeArrayStart(1)
			} else {
				yynn536 = 0
				for _, b := range yyq536 {
					if b {
						yynn536++
					}
				}
				r.EncodeMapStart(yynn536)
				yynn536 = 0
			}
			if yyr536 || yy2arr536 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq536[0] {
					yym538 := z.EncBinary()
					_ = yym538
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq536[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revision"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym539 := z.EncBinary()
					_ = yym539
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				}
			}
			if yyr536 || yy2arr536 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollbackConfig) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym540 := z.DecBinary()
	_ = yym540
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct541 := r.ContainerType()
		if yyct541 == codecSelferValueTypeMap1234 {
			yyl541 := r.ReadMapStart()
			if yyl541 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl541, d)
			}
		} else if yyct541 == codecSelferValueTypeArray1234 {
			yyl541 := r.ReadArrayStart()
			if yyl541 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl541, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RollbackConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys542Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys542Slc
	var yyhl542 bool = l >= 0
	for yyj542 := 0; ; yyj542++ {
		if yyhl542 {
			if yyj542 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys542Slc = r.DecodeBytes(yys542Slc, true, true)
		yys542 := string(yys542Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys542 {
		case "revision":
			if r.TryDecodeAsNil() {
				x.Revision = 0
			} else {
				x.Revision = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys542)
		} // end switch yys542
	} // end for yyj542
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollbackConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj544 int
	var yyb544 bool
	var yyhl544 bool = l >= 0
	yyj544++
	if yyhl544 {
		yyb544 = yyj544 > l
	} else {
		yyb544 = r.CheckBreak()
	}
	if yyb544 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Revision = 0
	} else {
		x.Revision = int64(r.DecodeInt(64))
	}
	for {
		yyj544++
		if yyhl544 {
			yyb544 = yyj544 > l
		} else {
			yyb544 = r.CheckBreak()
		}
		if yyb544 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj544-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym546 := z.EncBinary()
		_ = yym546
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep547 := !z.EncBinary()
			yy2arr547 := z.EncBasicHandle().StructToArray
			var yyq547 [2]bool
			_, _, _ = yysep547, yyq547, yy2arr547
			const yyr547 bool = false
			yyq547[0] = x.Type != ""
			yyq547[1] = x.RollingUpdate != nil
			var yynn547 int
			if yyr547 || yy2arr547 {
				r.EncodeArrayStart(2)
			} else {
				yynn547 = 0
				for _, b := range yyq547 {
					if b {
						yynn547++
					}
				}
				r.EncodeMapStart(yynn547)
				yynn547 = 0
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq547[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq547[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq547[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				}
			}
			if yyr547 || yy2arr547 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym550 := z.DecBinary()
	_ = yym550
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct551 := r.ContainerType()
		if yyct551 == codecSelferValueTypeMap1234 {
			yyl551 := r.ReadMapStart()
			if yyl551 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl551, d)
			}
		} else if yyct551 == codecSelferValueTypeArray1234 {
			yyl551 := r.ReadArrayStart()
			if yyl551 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl551, 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 yys552Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys552Slc
	var yyhl552 bool = l >= 0
	for yyj552 := 0; ; yyj552++ {
		if yyhl552 {
			if yyj552 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys552Slc = r.DecodeBytes(yys552Slc, true, true)
		yys552 := string(yys552Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys552 {
		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, yys552)
		} // end switch yys552
	} // end for yyj552
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj555 int
	var yyb555 bool
	var yyhl555 bool = l >= 0
	yyj555++
	if yyhl555 {
		yyb555 = yyj555 > l
	} else {
		yyb555 = r.CheckBreak()
	}
	if yyb555 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj555++
	if yyhl555 {
		yyb555 = yyj555 > l
	} else {
		yyb555 = r.CheckBreak()
	}
	if yyb555 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.RollingUpdate != nil {
			x.RollingUpdate = nil
		}
	} else {
		if x.RollingUpdate == nil {
			x.RollingUpdate = new(RollingUpdateDeployment)
		}
		x.RollingUpdate.CodecDecodeSelf(d)
	}
	for {
		yyj555++
		if yyhl555 {
			yyb555 = yyj555 > l
		} else {
			yyb555 = r.CheckBreak()
		}
		if yyb555 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj555-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym558 := z.EncBinary()
	_ = yym558
	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
	yym559 := z.DecBinary()
	_ = yym559
	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 {
		yym560 := z.EncBinary()
		_ = yym560
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep561 := !z.EncBinary()
			yy2arr561 := z.EncBasicHandle().StructToArray
			var yyq561 [2]bool
			_, _, _ = yysep561, yyq561, yy2arr561
			const yyr561 bool = false
			yyq561[0] = x.MaxUnavailable != nil
			yyq561[1] = x.MaxSurge != nil
			var yynn561 int
			if yyr561 || yy2arr561 {
				r.EncodeArrayStart(2)
			} else {
				yynn561 = 0
				for _, b := range yyq561 {
					if b {
						yynn561++
					}
				}
				r.EncodeMapStart(yynn561)
				yynn561 = 0
			}
			if yyr561 || yy2arr561 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq561[0] {
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym563 := z.EncBinary()
						_ = yym563
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym563 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq561[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxUnavailable == nil {
						r.EncodeNil()
					} else {
						yym564 := z.EncBinary()
						_ = yym564
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxUnavailable) {
						} else if !yym564 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxUnavailable)
						} else {
							z.EncFallback(x.MaxUnavailable)
						}
					}
				}
			}
			if yyr561 || yy2arr561 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq561[1] {
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym566 := z.EncBinary()
						_ = yym566
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym566 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq561[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MaxSurge == nil {
						r.EncodeNil()
					} else {
						yym567 := z.EncBinary()
						_ = yym567
						if false {
						} else if z.HasExtensions() && z.EncExt(x.MaxSurge) {
						} else if !yym567 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.MaxSurge)
						} else {
							z.EncFallback(x.MaxSurge)
						}
					}
				}
			}
			if yyr561 || yy2arr561 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RollingUpdateDeployment) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym568 := z.DecBinary()
	_ = yym568
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct569 := r.ContainerType()
		if yyct569 == codecSelferValueTypeMap1234 {
			yyl569 := r.ReadMapStart()
			if yyl569 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl569, d)
			}
		} else if yyct569 == codecSelferValueTypeArray1234 {
			yyl569 := r.ReadArrayStart()
			if yyl569 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl569, 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 yys570Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys570Slc
	var yyhl570 bool = l >= 0
	for yyj570 := 0; ; yyj570++ {
		if yyhl570 {
			if yyj570 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys570Slc = r.DecodeBytes(yys570Slc, true, true)
		yys570 := string(yys570Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys570 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				if x.MaxUnavailable != nil {
					x.MaxUnavailable = nil
				}
			} else {
				if x.MaxUnavailable == nil {
					x.MaxUnavailable = new(pkg5_intstr.IntOrString)
				}
				yym572 := z.DecBinary()
				_ = yym572
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
				} else if !yym572 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxUnavailable)
				} else {
					z.DecFallback(x.MaxUnavailable, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				if x.MaxSurge != nil {
					x.MaxSurge = nil
				}
			} else {
				if x.MaxSurge == nil {
					x.MaxSurge = new(pkg5_intstr.IntOrString)
				}
				yym574 := z.DecBinary()
				_ = yym574
				if false {
				} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
				} else if !yym574 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.MaxSurge)
				} else {
					z.DecFallback(x.MaxSurge, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys570)
		} // end switch yys570
	} // end for yyj570
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RollingUpdateDeployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj575 int
	var yyb575 bool
	var yyhl575 bool = l >= 0
	yyj575++
	if yyhl575 {
		yyb575 = yyj575 > l
	} else {
		yyb575 = r.CheckBreak()
	}
	if yyb575 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxUnavailable != nil {
			x.MaxUnavailable = nil
		}
	} else {
		if x.MaxUnavailable == nil {
			x.MaxUnavailable = new(pkg5_intstr.IntOrString)
		}
		yym577 := z.DecBinary()
		_ = yym577
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxUnavailable) {
		} else if !yym577 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxUnavailable)
		} else {
			z.DecFallback(x.MaxUnavailable, false)
		}
	}
	yyj575++
	if yyhl575 {
		yyb575 = yyj575 > l
	} else {
		yyb575 = r.CheckBreak()
	}
	if yyb575 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.MaxSurge != nil {
			x.MaxSurge = nil
		}
	} else {
		if x.MaxSurge == nil {
			x.MaxSurge = new(pkg5_intstr.IntOrString)
		}
		yym579 := z.DecBinary()
		_ = yym579
		if false {
		} else if z.HasExtensions() && z.DecExt(x.MaxSurge) {
		} else if !yym579 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.MaxSurge)
		} else {
			z.DecFallback(x.MaxSurge, false)
		}
	}
	for {
		yyj575++
		if yyhl575 {
			yyb575 = yyj575 > l
		} else {
			yyb575 = r.CheckBreak()
		}
		if yyb575 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj575-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym580 := z.EncBinary()
		_ = yym580
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep581 := !z.EncBinary()
			yy2arr581 := z.EncBasicHandle().StructToArray
			var yyq581 [5]bool
			_, _, _ = yysep581, yyq581, yy2arr581
			const yyr581 bool = false
			yyq581[0] = x.ObservedGeneration != 0
			yyq581[1] = x.Replicas != 0
			yyq581[2] = x.UpdatedReplicas != 0
			yyq581[3] = x.AvailableReplicas != 0
			yyq581[4] = x.UnavailableReplicas != 0
			var yynn581 int
			if yyr581 || yy2arr581 {
				r.EncodeArrayStart(5)
			} else {
				yynn581 = 0
				for _, b := range yyq581 {
					if b {
						yynn581++
					}
				}
				r.EncodeMapStart(yynn581)
				yynn581 = 0
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[0] {
					yym583 := z.EncBinary()
					_ = yym583
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym584 := z.EncBinary()
					_ = yym584
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[1] {
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym587 := z.EncBinary()
					_ = yym587
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[2] {
					yym589 := z.EncBinary()
					_ = yym589
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[3] {
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym593 := z.EncBinary()
					_ = yym593
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[4] {
					yym595 := z.EncBinary()
					_ = yym595
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq581[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym596 := z.EncBinary()
					_ = yym596
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym597 := z.DecBinary()
	_ = yym597
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct598 := r.ContainerType()
		if yyct598 == codecSelferValueTypeMap1234 {
			yyl598 := r.ReadMapStart()
			if yyl598 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl598, d)
			}
		} else if yyct598 == codecSelferValueTypeArray1234 {
			yyl598 := r.ReadArrayStart()
			if yyl598 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl598, 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 yys599Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys599Slc
	var yyhl599 bool = l >= 0
	for yyj599 := 0; ; yyj599++ {
		if yyhl599 {
			if yyj599 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys599Slc = r.DecodeBytes(yys599Slc, true, true)
		yys599 := string(yys599Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys599 {
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "updatedReplicas":
			if r.TryDecodeAsNil() {
				x.UpdatedReplicas = 0
			} else {
				x.UpdatedReplicas = int32(r.DecodeInt(32))
			}
		case "availableReplicas":
			if r.TryDecodeAsNil() {
				x.AvailableReplicas = 0
			} else {
				x.AvailableReplicas = int32(r.DecodeInt(32))
			}
		case "unavailableReplicas":
			if r.TryDecodeAsNil() {
				x.UnavailableReplicas = 0
			} else {
				x.UnavailableReplicas = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys599)
		} // end switch yys599
	} // end for yyj599
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj605 int
	var yyb605 bool
	var yyhl605 bool = l >= 0
	yyj605++
	if yyhl605 {
		yyb605 = yyj605 > l
	} else {
		yyb605 = r.CheckBreak()
	}
	if yyb605 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	yyj605++
	if yyhl605 {
		yyb605 = yyj605 > l
	} else {
		yyb605 = r.CheckBreak()
	}
	if yyb605 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj605++
	if yyhl605 {
		yyb605 = yyj605 > l
	} else {
		yyb605 = r.CheckBreak()
	}
	if yyb605 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int32(r.DecodeInt(32))
	}
	yyj605++
	if yyhl605 {
		yyb605 = yyj605 > l
	} else {
		yyb605 = r.CheckBreak()
	}
	if yyb605 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj605++
	if yyhl605 {
		yyb605 = yyj605 > l
	} else {
		yyb605 = r.CheckBreak()
	}
	if yyb605 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UnavailableReplicas = 0
	} else {
		x.UnavailableReplicas = int32(r.DecodeInt(32))
	}
	for {
		yyj605++
		if yyhl605 {
			yyb605 = yyj605 > l
		} else {
			yyb605 = r.CheckBreak()
		}
		if yyb605 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj605-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DeploymentList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym611 := z.EncBinary()
		_ = yym611
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep612 := !z.EncBinary()
			yy2arr612 := z.EncBasicHandle().StructToArray
			var yyq612 [4]bool
			_, _, _ = yysep612, yyq612, yy2arr612
			const yyr612 bool = false
			yyq612[0] = x.Kind != ""
			yyq612[1] = x.APIVersion != ""
			yyq612[2] = true
			var yynn612 int
			if yyr612 || yy2arr612 {
				r.EncodeArrayStart(4)
			} else {
				yynn612 = 1
				for _, b := range yyq612 {
					if b {
						yynn612++
					}
				}
				r.EncodeMapStart(yynn612)
				yynn612 = 0
			}
			if yyr612 || yy2arr612 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq612[0] {
					yym614 := z.EncBinary()
					_ = yym614
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq612[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym615 := z.EncBinary()
					_ = yym615
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr612 || yy2arr612 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq612[1] {
					yym617 := z.EncBinary()
					_ = yym617
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq612[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr612 || yy2arr612 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq612[2] {
					yy620 := &x.ListMeta
					yym621 := z.EncBinary()
					_ = yym621
					if false {
					} else if z.HasExtensions() && z.EncExt(yy620) {
					} else {
						z.EncFallback(yy620)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq612[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy622 := &x.ListMeta
					yym623 := z.EncBinary()
					_ = yym623
					if false {
					} else if z.HasExtensions() && z.EncExt(yy622) {
					} else {
						z.EncFallback(yy622)
					}
				}
			}
			if yyr612 || yy2arr612 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym625 := z.EncBinary()
					_ = yym625
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym626 := z.EncBinary()
					_ = yym626
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr612 || yy2arr612 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DeploymentList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym627 := z.DecBinary()
	_ = yym627
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct628 := r.ContainerType()
		if yyct628 == codecSelferValueTypeMap1234 {
			yyl628 := r.ReadMapStart()
			if yyl628 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl628, d)
			}
		} else if yyct628 == codecSelferValueTypeArray1234 {
			yyl628 := r.ReadArrayStart()
			if yyl628 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl628, 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 yys629Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys629Slc
	var yyhl629 bool = l >= 0
	for yyj629 := 0; ; yyj629++ {
		if yyhl629 {
			if yyj629 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys629Slc = r.DecodeBytes(yys629Slc, true, true)
		yys629 := string(yys629Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys629 {
		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 {
				yyv632 := &x.ListMeta
				yym633 := z.DecBinary()
				_ = yym633
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv632) {
				} else {
					z.DecFallback(yyv632, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv634 := &x.Items
				yym635 := z.DecBinary()
				_ = yym635
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv634), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys629)
		} // end switch yys629
	} // end for yyj629
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DeploymentList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj636 int
	var yyb636 bool
	var yyhl636 bool = l >= 0
	yyj636++
	if yyhl636 {
		yyb636 = yyj636 > l
	} else {
		yyb636 = r.CheckBreak()
	}
	if yyb636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj636++
	if yyhl636 {
		yyb636 = yyj636 > l
	} else {
		yyb636 = r.CheckBreak()
	}
	if yyb636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj636++
	if yyhl636 {
		yyb636 = yyj636 > l
	} else {
		yyb636 = r.CheckBreak()
	}
	if yyb636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv639 := &x.ListMeta
		yym640 := z.DecBinary()
		_ = yym640
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv639) {
		} else {
			z.DecFallback(yyv639, false)
		}
	}
	yyj636++
	if yyhl636 {
		yyb636 = yyj636 > l
	} else {
		yyb636 = r.CheckBreak()
	}
	if yyb636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv641 := &x.Items
		yym642 := z.DecBinary()
		_ = yym642
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv641), d)
		}
	}
	for {
		yyj636++
		if yyhl636 {
			yyb636 = yyj636 > l
		} else {
			yyb636 = r.CheckBreak()
		}
		if yyb636 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj636-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym643 := z.EncBinary()
		_ = yym643
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep644 := !z.EncBinary()
			yy2arr644 := z.EncBasicHandle().StructToArray
			var yyq644 [2]bool
			_, _, _ = yysep644, yyq644, yy2arr644
			const yyr644 bool = false
			yyq644[0] = x.Selector != nil
			var yynn644 int
			if yyr644 || yy2arr644 {
				r.EncodeArrayStart(2)
			} else {
				yynn644 = 1
				for _, b := range yyq644 {
					if b {
						yynn644++
					}
				}
				r.EncodeMapStart(yynn644)
				yynn644 = 0
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq644[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq644[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy647 := &x.Template
				yy647.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy648 := &x.Template
				yy648.CodecEncodeSelf(e)
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym649 := z.DecBinary()
	_ = yym649
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct650 := r.ContainerType()
		if yyct650 == codecSelferValueTypeMap1234 {
			yyl650 := r.ReadMapStart()
			if yyl650 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl650, d)
			}
		} else if yyct650 == codecSelferValueTypeArray1234 {
			yyl650 := r.ReadArrayStart()
			if yyl650 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl650, 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 yys651Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys651Slc
	var yyhl651 bool = l >= 0
	for yyj651 := 0; ; yyj651++ {
		if yyhl651 {
			if yyj651 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys651Slc = r.DecodeBytes(yys651Slc, true, true)
		yys651 := string(yys651Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys651 {
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv653 := &x.Template
				yyv653.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys651)
		} // end switch yys651
	} // end for yyj651
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj654 int
	var yyb654 bool
	var yyhl654 bool = l >= 0
	yyj654++
	if yyhl654 {
		yyb654 = yyj654 > l
	} else {
		yyb654 = r.CheckBreak()
	}
	if yyb654 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj654++
	if yyhl654 {
		yyb654 = yyj654 > l
	} else {
		yyb654 = r.CheckBreak()
	}
	if yyb654 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv656 := &x.Template
		yyv656.CodecDecodeSelf(d)
	}
	for {
		yyj654++
		if yyhl654 {
			yyb654 = yyj654 > l
		} else {
			yyb654 = r.CheckBreak()
		}
		if yyb654 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj654-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym657 := z.EncBinary()
		_ = yym657
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep658 := !z.EncBinary()
			yy2arr658 := z.EncBasicHandle().StructToArray
			var yyq658 [3]bool
			_, _, _ = yysep658, yyq658, yy2arr658
			const yyr658 bool = false
			var yynn658 int
			if yyr658 || yy2arr658 {
				r.EncodeArrayStart(3)
			} else {
				yynn658 = 3
				for _, b := range yyq658 {
					if b {
						yynn658++
					}
				}
				r.EncodeMapStart(yynn658)
				yynn658 = 0
			}
			if yyr658 || yy2arr658 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym660 := z.EncBinary()
				_ = yym660
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym661 := z.EncBinary()
				_ = yym661
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr658 || yy2arr658 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym663 := z.EncBinary()
				_ = yym663
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym664 := z.EncBinary()
				_ = yym664
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr658 || yy2arr658 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym666 := z.EncBinary()
				_ = yym666
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym667 := z.EncBinary()
				_ = yym667
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr658 || yy2arr658 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym668 := z.DecBinary()
	_ = yym668
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct669 := r.ContainerType()
		if yyct669 == codecSelferValueTypeMap1234 {
			yyl669 := r.ReadMapStart()
			if yyl669 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl669, d)
			}
		} else if yyct669 == codecSelferValueTypeArray1234 {
			yyl669 := r.ReadArrayStart()
			if yyl669 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl669, 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 yys670Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys670Slc
	var yyhl670 bool = l >= 0
	for yyj670 := 0; ; yyj670++ {
		if yyhl670 {
			if yyj670 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys670Slc = r.DecodeBytes(yys670Slc, true, true)
		yys670 := string(yys670Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys670 {
		case "currentNumberScheduled":
			if r.TryDecodeAsNil() {
				x.CurrentNumberScheduled = 0
			} else {
				x.CurrentNumberScheduled = int32(r.DecodeInt(32))
			}
		case "numberMisscheduled":
			if r.TryDecodeAsNil() {
				x.NumberMisscheduled = 0
			} else {
				x.NumberMisscheduled = int32(r.DecodeInt(32))
			}
		case "desiredNumberScheduled":
			if r.TryDecodeAsNil() {
				x.DesiredNumberScheduled = 0
			} else {
				x.DesiredNumberScheduled = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys670)
		} // end switch yys670
	} // end for yyj670
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj674 int
	var yyb674 bool
	var yyhl674 bool = l >= 0
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj674++
	if yyhl674 {
		yyb674 = yyj674 > l
	} else {
		yyb674 = r.CheckBreak()
	}
	if yyb674 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	for {
		yyj674++
		if yyhl674 {
			yyb674 = yyj674 > l
		} else {
			yyb674 = r.CheckBreak()
		}
		if yyb674 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj674-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym678 := z.EncBinary()
		_ = yym678
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep679 := !z.EncBinary()
			yy2arr679 := z.EncBasicHandle().StructToArray
			var yyq679 [5]bool
			_, _, _ = yysep679, yyq679, yy2arr679
			const yyr679 bool = false
			yyq679[0] = x.Kind != ""
			yyq679[1] = x.APIVersion != ""
			yyq679[2] = true
			yyq679[3] = true
			yyq679[4] = true
			var yynn679 int
			if yyr679 || yy2arr679 {
				r.EncodeArrayStart(5)
			} else {
				yynn679 = 0
				for _, b := range yyq679 {
					if b {
						yynn679++
					}
				}
				r.EncodeMapStart(yynn679)
				yynn679 = 0
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq679[0] {
					yym681 := z.EncBinary()
					_ = yym681
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq679[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym682 := z.EncBinary()
					_ = yym682
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq679[1] {
					yym684 := z.EncBinary()
					_ = yym684
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq679[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym685 := z.EncBinary()
					_ = yym685
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq679[2] {
					yy687 := &x.ObjectMeta
					yy687.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq679[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy688 := &x.ObjectMeta
					yy688.CodecEncodeSelf(e)
				}
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq679[3] {
					yy690 := &x.Spec
					yy690.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq679[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy691 := &x.Spec
					yy691.CodecEncodeSelf(e)
				}
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq679[4] {
					yy693 := &x.Status
					yy693.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq679[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy694 := &x.Status
					yy694.CodecEncodeSelf(e)
				}
			}
			if yyr679 || yy2arr679 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym695 := z.DecBinary()
	_ = yym695
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct696 := r.ContainerType()
		if yyct696 == codecSelferValueTypeMap1234 {
			yyl696 := r.ReadMapStart()
			if yyl696 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl696, d)
			}
		} else if yyct696 == codecSelferValueTypeArray1234 {
			yyl696 := r.ReadArrayStart()
			if yyl696 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl696, 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 yys697Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys697Slc
	var yyhl697 bool = l >= 0
	for yyj697 := 0; ; yyj697++ {
		if yyhl697 {
			if yyj697 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys697Slc = r.DecodeBytes(yys697Slc, true, true)
		yys697 := string(yys697Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys697 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv700 := &x.ObjectMeta
				yyv700.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv701 := &x.Spec
				yyv701.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv702 := &x.Status
				yyv702.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys697)
		} // end switch yys697
	} // end for yyj697
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj703 int
	var yyb703 bool
	var yyhl703 bool = l >= 0
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv706 := &x.ObjectMeta
		yyv706.CodecDecodeSelf(d)
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv707 := &x.Spec
		yyv707.CodecDecodeSelf(d)
	}
	yyj703++
	if yyhl703 {
		yyb703 = yyj703 > l
	} else {
		yyb703 = r.CheckBreak()
	}
	if yyb703 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv708 := &x.Status
		yyv708.CodecDecodeSelf(d)
	}
	for {
		yyj703++
		if yyhl703 {
			yyb703 = yyj703 > l
		} else {
			yyb703 = r.CheckBreak()
		}
		if yyb703 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj703-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *DaemonSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym709 := z.EncBinary()
		_ = yym709
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep710 := !z.EncBinary()
			yy2arr710 := z.EncBasicHandle().StructToArray
			var yyq710 [4]bool
			_, _, _ = yysep710, yyq710, yy2arr710
			const yyr710 bool = false
			yyq710[0] = x.Kind != ""
			yyq710[1] = x.APIVersion != ""
			yyq710[2] = true
			var yynn710 int
			if yyr710 || yy2arr710 {
				r.EncodeArrayStart(4)
			} else {
				yynn710 = 1
				for _, b := range yyq710 {
					if b {
						yynn710++
					}
				}
				r.EncodeMapStart(yynn710)
				yynn710 = 0
			}
			if yyr710 || yy2arr710 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq710[0] {
					yym712 := z.EncBinary()
					_ = yym712
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq710[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym713 := z.EncBinary()
					_ = yym713
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr710 || yy2arr710 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq710[1] {
					yym715 := z.EncBinary()
					_ = yym715
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq710[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym716 := z.EncBinary()
					_ = yym716
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr710 || yy2arr710 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq710[2] {
					yy718 := &x.ListMeta
					yym719 := z.EncBinary()
					_ = yym719
					if false {
					} else if z.HasExtensions() && z.EncExt(yy718) {
					} else {
						z.EncFallback(yy718)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq710[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy720 := &x.ListMeta
					yym721 := z.EncBinary()
					_ = yym721
					if false {
					} else if z.HasExtensions() && z.EncExt(yy720) {
					} else {
						z.EncFallback(yy720)
					}
				}
			}
			if yyr710 || yy2arr710 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym723 := z.EncBinary()
					_ = yym723
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym724 := z.EncBinary()
					_ = yym724
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr710 || yy2arr710 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *DaemonSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym725 := z.DecBinary()
	_ = yym725
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct726 := r.ContainerType()
		if yyct726 == codecSelferValueTypeMap1234 {
			yyl726 := r.ReadMapStart()
			if yyl726 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl726, d)
			}
		} else if yyct726 == codecSelferValueTypeArray1234 {
			yyl726 := r.ReadArrayStart()
			if yyl726 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl726, 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 yys727Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys727Slc
	var yyhl727 bool = l >= 0
	for yyj727 := 0; ; yyj727++ {
		if yyhl727 {
			if yyj727 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys727Slc = r.DecodeBytes(yys727Slc, true, true)
		yys727 := string(yys727Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys727 {
		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 {
				yyv730 := &x.ListMeta
				yym731 := z.DecBinary()
				_ = yym731
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv730) {
				} else {
					z.DecFallback(yyv730, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv732 := &x.Items
				yym733 := z.DecBinary()
				_ = yym733
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv732), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys727)
		} // end switch yys727
	} // end for yyj727
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *DaemonSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj734 int
	var yyb734 bool
	var yyhl734 bool = l >= 0
	yyj734++
	if yyhl734 {
		yyb734 = yyj734 > l
	} else {
		yyb734 = r.CheckBreak()
	}
	if yyb734 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj734++
	if yyhl734 {
		yyb734 = yyj734 > l
	} else {
		yyb734 = r.CheckBreak()
	}
	if yyb734 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj734++
	if yyhl734 {
		yyb734 = yyj734 > l
	} else {
		yyb734 = r.CheckBreak()
	}
	if yyb734 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv737 := &x.ListMeta
		yym738 := z.DecBinary()
		_ = yym738
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv737) {
		} else {
			z.DecFallback(yyv737, false)
		}
	}
	yyj734++
	if yyhl734 {
		yyb734 = yyj734 > l
	} else {
		yyb734 = r.CheckBreak()
	}
	if yyb734 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv739 := &x.Items
		yym740 := z.DecBinary()
		_ = yym740
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv739), d)
		}
	}
	for {
		yyj734++
		if yyhl734 {
			yyb734 = yyj734 > l
		} else {
			yyb734 = r.CheckBreak()
		}
		if yyb734 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj734-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ThirdPartyResourceDataList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym741 := z.EncBinary()
		_ = yym741
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep742 := !z.EncBinary()
			yy2arr742 := z.EncBasicHandle().StructToArray
			var yyq742 [4]bool
			_, _, _ = yysep742, yyq742, yy2arr742
			const yyr742 bool = false
			yyq742[0] = x.Kind != ""
			yyq742[1] = x.APIVersion != ""
			yyq742[2] = true
			var yynn742 int
			if yyr742 || yy2arr742 {
				r.EncodeArrayStart(4)
			} else {
				yynn742 = 1
				for _, b := range yyq742 {
					if b {
						yynn742++
					}
				}
				r.EncodeMapStart(yynn742)
				yynn742 = 0
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq742[0] {
					yym744 := z.EncBinary()
					_ = yym744
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq742[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym745 := z.EncBinary()
					_ = yym745
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq742[1] {
					yym747 := z.EncBinary()
					_ = yym747
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq742[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym748 := z.EncBinary()
					_ = yym748
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq742[2] {
					yy750 := &x.ListMeta
					yym751 := z.EncBinary()
					_ = yym751
					if false {
					} else if z.HasExtensions() && z.EncExt(yy750) {
					} else {
						z.EncFallback(yy750)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq742[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy752 := &x.ListMeta
					yym753 := z.EncBinary()
					_ = yym753
					if false {
					} else if z.HasExtensions() && z.EncExt(yy752) {
					} else {
						z.EncFallback(yy752)
					}
				}
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym755 := z.EncBinary()
					_ = yym755
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym756 := z.EncBinary()
					_ = yym756
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ThirdPartyResourceDataList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym757 := z.DecBinary()
	_ = yym757
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct758 := r.ContainerType()
		if yyct758 == codecSelferValueTypeMap1234 {
			yyl758 := r.ReadMapStart()
			if yyl758 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl758, d)
			}
		} else if yyct758 == codecSelferValueTypeArray1234 {
			yyl758 := r.ReadArrayStart()
			if yyl758 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl758, 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 yys759Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys759Slc
	var yyhl759 bool = l >= 0
	for yyj759 := 0; ; yyj759++ {
		if yyhl759 {
			if yyj759 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys759Slc = r.DecodeBytes(yys759Slc, true, true)
		yys759 := string(yys759Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys759 {
		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 {
				yyv762 := &x.ListMeta
				yym763 := z.DecBinary()
				_ = yym763
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv762) {
				} else {
					z.DecFallback(yyv762, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv764 := &x.Items
				yym765 := z.DecBinary()
				_ = yym765
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv764), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys759)
		} // end switch yys759
	} // end for yyj759
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ThirdPartyResourceDataList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj766 int
	var yyb766 bool
	var yyhl766 bool = l >= 0
	yyj766++
	if yyhl766 {
		yyb766 = yyj766 > l
	} else {
		yyb766 = r.CheckBreak()
	}
	if yyb766 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj766++
	if yyhl766 {
		yyb766 = yyj766 > l
	} else {
		yyb766 = r.CheckBreak()
	}
	if yyb766 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj766++
	if yyhl766 {
		yyb766 = yyj766 > l
	} else {
		yyb766 = r.CheckBreak()
	}
	if yyb766 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv769 := &x.ListMeta
		yym770 := z.DecBinary()
		_ = yym770
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv769) {
		} else {
			z.DecFallback(yyv769, false)
		}
	}
	yyj766++
	if yyhl766 {
		yyb766 = yyj766 > l
	} else {
		yyb766 = r.CheckBreak()
	}
	if yyb766 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv771 := &x.Items
		yym772 := z.DecBinary()
		_ = yym772
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv771), d)
		}
	}
	for {
		yyj766++
		if yyhl766 {
			yyb766 = yyj766 > l
		} else {
			yyb766 = r.CheckBreak()
		}
		if yyb766 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj766-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym773 := z.EncBinary()
		_ = yym773
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep774 := !z.EncBinary()
			yy2arr774 := z.EncBasicHandle().StructToArray
			var yyq774 [5]bool
			_, _, _ = yysep774, yyq774, yy2arr774
			const yyr774 bool = false
			yyq774[0] = x.Kind != ""
			yyq774[1] = x.APIVersion != ""
			yyq774[2] = true
			yyq774[3] = true
			yyq774[4] = true
			var yynn774 int
			if yyr774 || yy2arr774 {
				r.EncodeArrayStart(5)
			} else {
				yynn774 = 0
				for _, b := range yyq774 {
					if b {
						yynn774++
					}
				}
				r.EncodeMapStart(yynn774)
				yynn774 = 0
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq774[0] {
					yym776 := z.EncBinary()
					_ = yym776
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq774[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym777 := z.EncBinary()
					_ = yym777
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq774[1] {
					yym779 := z.EncBinary()
					_ = yym779
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq774[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym780 := z.EncBinary()
					_ = yym780
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq774[2] {
					yy782 := &x.ObjectMeta
					yy782.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq774[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy783 := &x.ObjectMeta
					yy783.CodecEncodeSelf(e)
				}
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq774[3] {
					yy785 := &x.Spec
					yy785.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq774[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy786 := &x.Spec
					yy786.CodecEncodeSelf(e)
				}
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq774[4] {
					yy788 := &x.Status
					yy788.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq774[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy789 := &x.Status
					yy789.CodecEncodeSelf(e)
				}
			}
			if yyr774 || yy2arr774 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym790 := z.DecBinary()
	_ = yym790
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct791 := r.ContainerType()
		if yyct791 == codecSelferValueTypeMap1234 {
			yyl791 := r.ReadMapStart()
			if yyl791 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl791, d)
			}
		} else if yyct791 == codecSelferValueTypeArray1234 {
			yyl791 := r.ReadArrayStart()
			if yyl791 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl791, 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 yys792Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys792Slc
	var yyhl792 bool = l >= 0
	for yyj792 := 0; ; yyj792++ {
		if yyhl792 {
			if yyj792 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys792Slc = r.DecodeBytes(yys792Slc, true, true)
		yys792 := string(yys792Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys792 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv795 := &x.ObjectMeta
				yyv795.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv796 := &x.Spec
				yyv796.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv797 := &x.Status
				yyv797.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys792)
		} // end switch yys792
	} // end for yyj792
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj798 int
	var yyb798 bool
	var yyhl798 bool = l >= 0
	yyj798++
	if yyhl798 {
		yyb798 = yyj798 > l
	} else {
		yyb798 = r.CheckBreak()
	}
	if yyb798 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj798++
	if yyhl798 {
		yyb798 = yyj798 > l
	} else {
		yyb798 = r.CheckBreak()
	}
	if yyb798 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj798++
	if yyhl798 {
		yyb798 = yyj798 > l
	} else {
		yyb798 = r.CheckBreak()
	}
	if yyb798 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv801 := &x.ObjectMeta
		yyv801.CodecDecodeSelf(d)
	}
	yyj798++
	if yyhl798 {
		yyb798 = yyj798 > l
	} else {
		yyb798 = r.CheckBreak()
	}
	if yyb798 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv802 := &x.Spec
		yyv802.CodecDecodeSelf(d)
	}
	yyj798++
	if yyhl798 {
		yyb798 = yyj798 > l
	} else {
		yyb798 = r.CheckBreak()
	}
	if yyb798 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv803 := &x.Status
		yyv803.CodecDecodeSelf(d)
	}
	for {
		yyj798++
		if yyhl798 {
			yyb798 = yyj798 > l
		} else {
			yyb798 = r.CheckBreak()
		}
		if yyb798 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj798-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym804 := z.EncBinary()
		_ = yym804
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep805 := !z.EncBinary()
			yy2arr805 := z.EncBasicHandle().StructToArray
			var yyq805 [4]bool
			_, _, _ = yysep805, yyq805, yy2arr805
			const yyr805 bool = false
			yyq805[0] = x.Kind != ""
			yyq805[1] = x.APIVersion != ""
			yyq805[2] = true
			var yynn805 int
			if yyr805 || yy2arr805 {
				r.EncodeArrayStart(4)
			} else {
				yynn805 = 1
				for _, b := range yyq805 {
					if b {
						yynn805++
					}
				}
				r.EncodeMapStart(yynn805)
				yynn805 = 0
			}
			if yyr805 || yy2arr805 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq805[0] {
					yym807 := z.EncBinary()
					_ = yym807
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq805[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym808 := z.EncBinary()
					_ = yym808
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr805 || yy2arr805 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq805[1] {
					yym810 := z.EncBinary()
					_ = yym810
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq805[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym811 := z.EncBinary()
					_ = yym811
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr805 || yy2arr805 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq805[2] {
					yy813 := &x.ListMeta
					yym814 := z.EncBinary()
					_ = yym814
					if false {
					} else if z.HasExtensions() && z.EncExt(yy813) {
					} else {
						z.EncFallback(yy813)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq805[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy815 := &x.ListMeta
					yym816 := z.EncBinary()
					_ = yym816
					if false {
					} else if z.HasExtensions() && z.EncExt(yy815) {
					} else {
						z.EncFallback(yy815)
					}
				}
			}
			if yyr805 || yy2arr805 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym818 := z.EncBinary()
					_ = yym818
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym819 := z.EncBinary()
					_ = yym819
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yyr805 || yy2arr805 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym820 := z.DecBinary()
	_ = yym820
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct821 := r.ContainerType()
		if yyct821 == codecSelferValueTypeMap1234 {
			yyl821 := r.ReadMapStart()
			if yyl821 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl821, d)
			}
		} else if yyct821 == codecSelferValueTypeArray1234 {
			yyl821 := r.ReadArrayStart()
			if yyl821 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl821, 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 yys822Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys822Slc
	var yyhl822 bool = l >= 0
	for yyj822 := 0; ; yyj822++ {
		if yyhl822 {
			if yyj822 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys822Slc = r.DecodeBytes(yys822Slc, true, true)
		yys822 := string(yys822Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys822 {
		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 {
				yyv825 := &x.ListMeta
				yym826 := z.DecBinary()
				_ = yym826
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv825) {
				} else {
					z.DecFallback(yyv825, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv827 := &x.Items
				yym828 := z.DecBinary()
				_ = yym828
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv827), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys822)
		} // end switch yys822
	} // end for yyj822
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj829 int
	var yyb829 bool
	var yyhl829 bool = l >= 0
	yyj829++
	if yyhl829 {
		yyb829 = yyj829 > l
	} else {
		yyb829 = r.CheckBreak()
	}
	if yyb829 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj829++
	if yyhl829 {
		yyb829 = yyj829 > l
	} else {
		yyb829 = r.CheckBreak()
	}
	if yyb829 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj829++
	if yyhl829 {
		yyb829 = yyj829 > l
	} else {
		yyb829 = r.CheckBreak()
	}
	if yyb829 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv832 := &x.ListMeta
		yym833 := z.DecBinary()
		_ = yym833
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv832) {
		} else {
			z.DecFallback(yyv832, false)
		}
	}
	yyj829++
	if yyhl829 {
		yyb829 = yyj829 > l
	} else {
		yyb829 = r.CheckBreak()
	}
	if yyb829 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv834 := &x.Items
		yym835 := z.DecBinary()
		_ = yym835
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv834), d)
		}
	}
	for {
		yyj829++
		if yyhl829 {
			yyb829 = yyj829 > l
		} else {
			yyb829 = r.CheckBreak()
		}
		if yyb829 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj829-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym836 := z.EncBinary()
		_ = yym836
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep837 := !z.EncBinary()
			yy2arr837 := z.EncBasicHandle().StructToArray
			var yyq837 [6]bool
			_, _, _ = yysep837, yyq837, yy2arr837
			const yyr837 bool = false
			yyq837[0] = x.Parallelism != nil
			yyq837[1] = x.Completions != nil
			yyq837[2] = x.ActiveDeadlineSeconds != nil
			yyq837[3] = x.Selector != nil
			yyq837[4] = x.AutoSelector != nil
			var yynn837 int
			if yyr837 || yy2arr837 {
				r.EncodeArrayStart(6)
			} else {
				yynn837 = 1
				for _, b := range yyq837 {
					if b {
						yynn837++
					}
				}
				r.EncodeMapStart(yynn837)
				yynn837 = 0
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy839 := *x.Parallelism
						yym840 := z.EncBinary()
						_ = yym840
						if false {
						} else {
							r.EncodeInt(int64(yy839))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy841 := *x.Parallelism
						yym842 := z.EncBinary()
						_ = yym842
						if false {
						} else {
							r.EncodeInt(int64(yy841))
						}
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy844 := *x.Completions
						yym845 := z.EncBinary()
						_ = yym845
						if false {
						} else {
							r.EncodeInt(int64(yy844))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy846 := *x.Completions
						yym847 := z.EncBinary()
						_ = yym847
						if false {
						} else {
							r.EncodeInt(int64(yy846))
						}
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[2] {
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy849 := *x.ActiveDeadlineSeconds
						yym850 := z.EncBinary()
						_ = yym850
						if false {
						} else {
							r.EncodeInt(int64(yy849))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy851 := *x.ActiveDeadlineSeconds
						yym852 := z.EncBinary()
						_ = yym852
						if false {
						} else {
							r.EncodeInt(int64(yy851))
						}
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[3] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq837[4] {
					if x.AutoSelector == nil {
						r.EncodeNil()
					} else {
						yy855 := *x.AutoSelector
						yym856 := z.EncBinary()
						_ = yym856
						if false {
						} else {
							r.EncodeBool(bool(yy855))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq837[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("autoSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AutoSelector == nil {
						r.EncodeNil()
					} else {
						yy857 := *x.AutoSelector
						yym858 := z.EncBinary()
						_ = yym858
						if false {
						} else {
							r.EncodeBool(bool(yy857))
						}
					}
				}
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy860 := &x.Template
				yy860.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy861 := &x.Template
				yy861.CodecEncodeSelf(e)
			}
			if yyr837 || yy2arr837 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym862 := z.DecBinary()
	_ = yym862
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct863 := r.ContainerType()
		if yyct863 == codecSelferValueTypeMap1234 {
			yyl863 := r.ReadMapStart()
			if yyl863 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl863, d)
			}
		} else if yyct863 == codecSelferValueTypeArray1234 {
			yyl863 := r.ReadArrayStart()
			if yyl863 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl863, 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 yys864Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys864Slc
	var yyhl864 bool = l >= 0
	for yyj864 := 0; ; yyj864++ {
		if yyhl864 {
			if yyj864 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys864Slc = r.DecodeBytes(yys864Slc, true, true)
		yys864 := string(yys864Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys864 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int32)
				}
				yym866 := z.DecBinary()
				_ = yym866
				if false {
				} else {
					*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
				}
			}
		case "completions":
			if r.TryDecodeAsNil() {
				if x.Completions != nil {
					x.Completions = nil
				}
			} else {
				if x.Completions == nil {
					x.Completions = new(int32)
				}
				yym868 := z.DecBinary()
				_ = yym868
				if false {
				} else {
					*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
				}
			}
		case "activeDeadlineSeconds":
			if r.TryDecodeAsNil() {
				if x.ActiveDeadlineSeconds != nil {
					x.ActiveDeadlineSeconds = nil
				}
			} else {
				if x.ActiveDeadlineSeconds == nil {
					x.ActiveDeadlineSeconds = new(int64)
				}
				yym870 := z.DecBinary()
				_ = yym870
				if false {
				} else {
					*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
				}
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "autoSelector":
			if r.TryDecodeAsNil() {
				if x.AutoSelector != nil {
					x.AutoSelector = nil
				}
			} else {
				if x.AutoSelector == nil {
					x.AutoSelector = new(bool)
				}
				yym873 := z.DecBinary()
				_ = yym873
				if false {
				} else {
					*((*bool)(x.AutoSelector)) = r.DecodeBool()
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv874 := &x.Template
				yyv874.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys864)
		} // end switch yys864
	} // end for yyj864
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobSpec) 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 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Parallelism != nil {
			x.Parallelism = nil
		}
	} else {
		if x.Parallelism == nil {
			x.Parallelism = new(int32)
		}
		yym877 := z.DecBinary()
		_ = yym877
		if false {
		} else {
			*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
		}
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Completions != nil {
			x.Completions = nil
		}
	} else {
		if x.Completions == nil {
			x.Completions = new(int32)
		}
		yym879 := z.DecBinary()
		_ = yym879
		if false {
		} else {
			*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
		}
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ActiveDeadlineSeconds != nil {
			x.ActiveDeadlineSeconds = nil
		}
	} else {
		if x.ActiveDeadlineSeconds == nil {
			x.ActiveDeadlineSeconds = new(int64)
		}
		yym881 := z.DecBinary()
		_ = yym881
		if false {
		} else {
			*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.AutoSelector != nil {
			x.AutoSelector = nil
		}
	} else {
		if x.AutoSelector == nil {
			x.AutoSelector = new(bool)
		}
		yym884 := z.DecBinary()
		_ = yym884
		if false {
		} else {
			*((*bool)(x.AutoSelector)) = r.DecodeBool()
		}
	}
	yyj875++
	if yyhl875 {
		yyb875 = yyj875 > l
	} else {
		yyb875 = r.CheckBreak()
	}
	if yyb875 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv885 := &x.Template
		yyv885.CodecDecodeSelf(d)
	}
	for {
		yyj875++
		if yyhl875 {
			yyb875 = yyj875 > l
		} else {
			yyb875 = r.CheckBreak()
		}
		if yyb875 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj875-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *JobStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym886 := z.EncBinary()
		_ = yym886
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep887 := !z.EncBinary()
			yy2arr887 := z.EncBasicHandle().StructToArray
			var yyq887 [6]bool
			_, _, _ = yysep887, yyq887, yy2arr887
			const yyr887 bool = false
			yyq887[0] = len(x.Conditions) != 0
			yyq887[1] = x.StartTime != nil
			yyq887[2] = x.CompletionTime != nil
			yyq887[3] = x.Active != 0
			yyq887[4] = x.Succeeded != 0
			yyq887[5] = x.Failed != 0
			var yynn887 int
			if yyr887 || yy2arr887 {
				r.EncodeArrayStart(6)
			} else {
				yynn887 = 0
				for _, b := range yyq887 {
					if b {
						yynn887++
					}
				}
				r.EncodeMapStart(yynn887)
				yynn887 = 0
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym889 := z.EncBinary()
						_ = yym889
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq887[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym890 := z.EncBinary()
						_ = yym890
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym892 := z.EncBinary()
						_ = yym892
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym892 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym892 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq887[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym893 := z.EncBinary()
						_ = yym893
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym893 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym893 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym895 := z.EncBinary()
						_ = yym895
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym895 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym895 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq887[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym896 := z.EncBinary()
						_ = yym896
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym896 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym896 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[3] {
					yym898 := z.EncBinary()
					_ = yym898
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq887[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym899 := z.EncBinary()
					_ = yym899
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[4] {
					yym901 := z.EncBinary()
					_ = yym901
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq887[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym902 := z.EncBinary()
					_ = yym902
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq887[5] {
					yym904 := z.EncBinary()
					_ = yym904
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq887[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym905 := z.EncBinary()
					_ = yym905
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yyr887 || yy2arr887 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym906 := z.DecBinary()
	_ = yym906
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct907 := r.ContainerType()
		if yyct907 == codecSelferValueTypeMap1234 {
			yyl907 := r.ReadMapStart()
			if yyl907 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl907, d)
			}
		} else if yyct907 == codecSelferValueTypeArray1234 {
			yyl907 := r.ReadArrayStart()
			if yyl907 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl907, 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 yys908Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys908Slc
	var yyhl908 bool = l >= 0
	for yyj908 := 0; ; yyj908++ {
		if yyhl908 {
			if yyj908 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys908Slc = r.DecodeBytes(yys908Slc, true, true)
		yys908 := string(yys908Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys908 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv909 := &x.Conditions
				yym910 := z.DecBinary()
				_ = yym910
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv909), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym912 := z.DecBinary()
				_ = yym912
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym912 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym912 && 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)
				}
				yym914 := z.DecBinary()
				_ = yym914
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym914 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym914 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.CompletionTime)
				} else {
					z.DecFallback(x.CompletionTime, false)
				}
			}
		case "active":
			if r.TryDecodeAsNil() {
				x.Active = 0
			} else {
				x.Active = int32(r.DecodeInt(32))
			}
		case "succeeded":
			if r.TryDecodeAsNil() {
				x.Succeeded = 0
			} else {
				x.Succeeded = int32(r.DecodeInt(32))
			}
		case "failed":
			if r.TryDecodeAsNil() {
				x.Failed = 0
			} else {
				x.Failed = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys908)
		} // end switch yys908
	} // end for yyj908
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj918 int
	var yyb918 bool
	var yyhl918 bool = l >= 0
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv919 := &x.Conditions
		yym920 := z.DecBinary()
		_ = yym920
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv919), d)
		}
	}
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.StartTime != nil {
			x.StartTime = nil
		}
	} else {
		if x.StartTime == nil {
			x.StartTime = new(pkg1_unversioned.Time)
		}
		yym922 := z.DecBinary()
		_ = yym922
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym922 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym922 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.CompletionTime != nil {
			x.CompletionTime = nil
		}
	} else {
		if x.CompletionTime == nil {
			x.CompletionTime = new(pkg1_unversioned.Time)
		}
		yym924 := z.DecBinary()
		_ = yym924
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym924 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym924 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int32(r.DecodeInt(32))
	}
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int32(r.DecodeInt(32))
	}
	yyj918++
	if yyhl918 {
		yyb918 = yyj918 > l
	} else {
		yyb918 = r.CheckBreak()
	}
	if yyb918 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int32(r.DecodeInt(32))
	}
	for {
		yyj918++
		if yyhl918 {
			yyb918 = yyj918 > l
		} else {
			yyb918 = r.CheckBreak()
		}
		if yyb918 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj918-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym928 := z.EncBinary()
	_ = yym928
	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
	yym929 := z.DecBinary()
	_ = yym929
	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 {
		yym930 := z.EncBinary()
		_ = yym930
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep931 := !z.EncBinary()
			yy2arr931 := z.EncBasicHandle().StructToArray
			var yyq931 [6]bool
			_, _, _ = yysep931, yyq931, yy2arr931
			const yyr931 bool = false
			yyq931[2] = true
			yyq931[3] = true
			yyq931[4] = x.Reason != ""
			yyq931[5] = x.Message != ""
			var yynn931 int
			if yyr931 || yy2arr931 {
				r.EncodeArrayStart(6)
			} else {
				yynn931 = 2
				for _, b := range yyq931 {
					if b {
						yynn931++
					}
				}
				r.EncodeMapStart(yynn931)
				yynn931 = 0
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym934 := z.EncBinary()
				_ = yym934
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym935 := z.EncBinary()
				_ = yym935
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[2] {
					yy937 := &x.LastProbeTime
					yym938 := z.EncBinary()
					_ = yym938
					if false {
					} else if z.HasExtensions() && z.EncExt(yy937) {
					} else if yym938 {
						z.EncBinaryMarshal(yy937)
					} else if !yym938 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy937)
					} else {
						z.EncFallback(yy937)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq931[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy939 := &x.LastProbeTime
					yym940 := z.EncBinary()
					_ = yym940
					if false {
					} else if z.HasExtensions() && z.EncExt(yy939) {
					} else if yym940 {
						z.EncBinaryMarshal(yy939)
					} else if !yym940 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy939)
					} else {
						z.EncFallback(yy939)
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[3] {
					yy942 := &x.LastTransitionTime
					yym943 := z.EncBinary()
					_ = yym943
					if false {
					} else if z.HasExtensions() && z.EncExt(yy942) {
					} else if yym943 {
						z.EncBinaryMarshal(yy942)
					} else if !yym943 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy942)
					} else {
						z.EncFallback(yy942)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq931[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy944 := &x.LastTransitionTime
					yym945 := z.EncBinary()
					_ = yym945
					if false {
					} else if z.HasExtensions() && z.EncExt(yy944) {
					} else if yym945 {
						z.EncBinaryMarshal(yy944)
					} else if !yym945 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy944)
					} else {
						z.EncFallback(yy944)
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[4] {
					yym947 := z.EncBinary()
					_ = yym947
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq931[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym948 := z.EncBinary()
					_ = yym948
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[5] {
					yym950 := z.EncBinary()
					_ = yym950
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq931[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym951 := z.EncBinary()
					_ = yym951
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *JobCondition) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym952 := z.DecBinary()
	_ = yym952
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct953 := r.ContainerType()
		if yyct953 == codecSelferValueTypeMap1234 {
			yyl953 := r.ReadMapStart()
			if yyl953 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl953, d)
			}
		} else if yyct953 == codecSelferValueTypeArray1234 {
			yyl953 := r.ReadArrayStart()
			if yyl953 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl953, 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 yys954Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys954Slc
	var yyhl954 bool = l >= 0
	for yyj954 := 0; ; yyj954++ {
		if yyhl954 {
			if yyj954 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys954Slc = r.DecodeBytes(yys954Slc, true, true)
		yys954 := string(yys954Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys954 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = JobConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
			}
		case "lastProbeTime":
			if r.TryDecodeAsNil() {
				x.LastProbeTime = pkg1_unversioned.Time{}
			} else {
				yyv957 := &x.LastProbeTime
				yym958 := z.DecBinary()
				_ = yym958
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv957) {
				} else if yym958 {
					z.DecBinaryUnmarshal(yyv957)
				} else if !yym958 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv957)
				} else {
					z.DecFallback(yyv957, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv959 := &x.LastTransitionTime
				yym960 := z.DecBinary()
				_ = yym960
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv959) {
				} else if yym960 {
					z.DecBinaryUnmarshal(yyv959)
				} else if !yym960 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv959)
				} else {
					z.DecFallback(yyv959, 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, yys954)
		} // end switch yys954
	} // end for yyj954
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *JobCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj963 int
	var yyb963 bool
	var yyhl963 bool = l >= 0
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv966 := &x.LastProbeTime
		yym967 := z.DecBinary()
		_ = yym967
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv966) {
		} else if yym967 {
			z.DecBinaryUnmarshal(yyv966)
		} else if !yym967 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv966)
		} else {
			z.DecFallback(yyv966, false)
		}
	}
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv968 := &x.LastTransitionTime
		yym969 := z.DecBinary()
		_ = yym969
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv968) {
		} else if yym969 {
			z.DecBinaryUnmarshal(yyv968)
		} else if !yym969 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv968)
		} else {
			z.DecFallback(yyv968, false)
		}
	}
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj963++
	if yyhl963 {
		yyb963 = yyj963 > l
	} else {
		yyb963 = r.CheckBreak()
	}
	if yyb963 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj963++
		if yyhl963 {
			yyb963 = yyj963 > l
		} else {
			yyb963 = r.CheckBreak()
		}
		if yyb963 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj963-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym972 := z.EncBinary()
		_ = yym972
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep973 := !z.EncBinary()
			yy2arr973 := z.EncBasicHandle().StructToArray
			var yyq973 [5]bool
			_, _, _ = yysep973, yyq973, yy2arr973
			const yyr973 bool = false
			yyq973[0] = x.Kind != ""
			yyq973[1] = x.APIVersion != ""
			yyq973[2] = true
			yyq973[3] = true
			yyq973[4] = true
			var yynn973 int
			if yyr973 || yy2arr973 {
				r.EncodeArrayStart(5)
			} else {
				yynn973 = 0
				for _, b := range yyq973 {
					if b {
						yynn973++
					}
				}
				r.EncodeMapStart(yynn973)
				yynn973 = 0
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq973[0] {
					yym975 := z.EncBinary()
					_ = yym975
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq973[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym976 := z.EncBinary()
					_ = yym976
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq973[1] {
					yym978 := z.EncBinary()
					_ = yym978
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq973[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym979 := z.EncBinary()
					_ = yym979
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq973[2] {
					yy981 := &x.ObjectMeta
					yy981.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq973[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy982 := &x.ObjectMeta
					yy982.CodecEncodeSelf(e)
				}
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq973[3] {
					yy984 := &x.Spec
					yy984.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq973[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy985 := &x.Spec
					yy985.CodecEncodeSelf(e)
				}
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq973[4] {
					yy987 := &x.Status
					yy987.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq973[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy988 := &x.Status
					yy988.CodecEncodeSelf(e)
				}
			}
			if yyr973 || yy2arr973 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *Ingress) 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 {
		yyct990 := r.ContainerType()
		if yyct990 == codecSelferValueTypeMap1234 {
			yyl990 := r.ReadMapStart()
			if yyl990 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl990, d)
			}
		} else if yyct990 == codecSelferValueTypeArray1234 {
			yyl990 := r.ReadArrayStart()
			if yyl990 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl990, 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 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
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys991Slc = r.DecodeBytes(yys991Slc, true, true)
		yys991 := string(yys991Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys991 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv994 := &x.ObjectMeta
				yyv994.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv995 := &x.Spec
				yyv995.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv996 := &x.Status
				yyv996.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys991)
		} // end switch yys991
	} // end for yyj991
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *Ingress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj997 int
	var yyb997 bool
	var yyhl997 bool = l >= 0
	yyj997++
	if yyhl997 {
		yyb997 = yyj997 > l
	} else {
		yyb997 = r.CheckBreak()
	}
	if yyb997 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj997++
	if yyhl997 {
		yyb997 = yyj997 > l
	} else {
		yyb997 = r.CheckBreak()
	}
	if yyb997 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj997++
	if yyhl997 {
		yyb997 = yyj997 > l
	} else {
		yyb997 = r.CheckBreak()
	}
	if yyb997 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1000 := &x.ObjectMeta
		yyv1000.CodecDecodeSelf(d)
	}
	yyj997++
	if yyhl997 {
		yyb997 = yyj997 > l
	} else {
		yyb997 = r.CheckBreak()
	}
	if yyb997 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv1001 := &x.Spec
		yyv1001.CodecDecodeSelf(d)
	}
	yyj997++
	if yyhl997 {
		yyb997 = yyj997 > l
	} else {
		yyb997 = r.CheckBreak()
	}
	if yyb997 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv1002 := &x.Status
		yyv1002.CodecDecodeSelf(d)
	}
	for {
		yyj997++
		if yyhl997 {
			yyb997 = yyj997 > l
		} else {
			yyb997 = r.CheckBreak()
		}
		if yyb997 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj997-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1003 := z.EncBinary()
		_ = yym1003
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1004 := !z.EncBinary()
			yy2arr1004 := z.EncBasicHandle().StructToArray
			var yyq1004 [4]bool
			_, _, _ = yysep1004, yyq1004, yy2arr1004
			const yyr1004 bool = false
			yyq1004[0] = x.Kind != ""
			yyq1004[1] = x.APIVersion != ""
			yyq1004[2] = true
			var yynn1004 int
			if yyr1004 || yy2arr1004 {
				r.EncodeArrayStart(4)
			} else {
				yynn1004 = 1
				for _, b := range yyq1004 {
					if b {
						yynn1004++
					}
				}
				r.EncodeMapStart(yynn1004)
				yynn1004 = 0
			}
			if yyr1004 || yy2arr1004 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1004[0] {
					yym1006 := z.EncBinary()
					_ = yym1006
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1004[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1007 := z.EncBinary()
					_ = yym1007
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1004 || yy2arr1004 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1004[1] {
					yym1009 := z.EncBinary()
					_ = yym1009
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1004[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1010 := z.EncBinary()
					_ = yym1010
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1004 || yy2arr1004 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1004[2] {
					yy1012 := &x.ListMeta
					yym1013 := z.EncBinary()
					_ = yym1013
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1012) {
					} else {
						z.EncFallback(yy1012)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1004[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1014 := &x.ListMeta
					yym1015 := z.EncBinary()
					_ = yym1015
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1014) {
					} else {
						z.EncFallback(yy1014)
					}
				}
			}
			if yyr1004 || yy2arr1004 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1017 := z.EncBinary()
					_ = yym1017
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1018 := z.EncBinary()
					_ = yym1018
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr1004 || yy2arr1004 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1019 := z.DecBinary()
	_ = yym1019
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1020 := r.ContainerType()
		if yyct1020 == codecSelferValueTypeMap1234 {
			yyl1020 := r.ReadMapStart()
			if yyl1020 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1020, d)
			}
		} else if yyct1020 == codecSelferValueTypeArray1234 {
			yyl1020 := r.ReadArrayStart()
			if yyl1020 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1020, 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 yys1021Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1021Slc
	var yyhl1021 bool = l >= 0
	for yyj1021 := 0; ; yyj1021++ {
		if yyhl1021 {
			if yyj1021 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1021Slc = r.DecodeBytes(yys1021Slc, true, true)
		yys1021 := string(yys1021Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1021 {
		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 {
				yyv1024 := &x.ListMeta
				yym1025 := z.DecBinary()
				_ = yym1025
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1024) {
				} else {
					z.DecFallback(yyv1024, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1026 := &x.Items
				yym1027 := z.DecBinary()
				_ = yym1027
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv1026), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1021)
		} // end switch yys1021
	} // end for yyj1021
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1028 int
	var yyb1028 bool
	var yyhl1028 bool = l >= 0
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1031 := &x.ListMeta
		yym1032 := z.DecBinary()
		_ = yym1032
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1031) {
		} else {
			z.DecFallback(yyv1031, false)
		}
	}
	yyj1028++
	if yyhl1028 {
		yyb1028 = yyj1028 > l
	} else {
		yyb1028 = r.CheckBreak()
	}
	if yyb1028 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1033 := &x.Items
		yym1034 := z.DecBinary()
		_ = yym1034
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv1033), d)
		}
	}
	for {
		yyj1028++
		if yyhl1028 {
			yyb1028 = yyj1028 > l
		} else {
			yyb1028 = r.CheckBreak()
		}
		if yyb1028 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1028-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1035 := z.EncBinary()
		_ = yym1035
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1036 := !z.EncBinary()
			yy2arr1036 := z.EncBasicHandle().StructToArray
			var yyq1036 [3]bool
			_, _, _ = yysep1036, yyq1036, yy2arr1036
			const yyr1036 bool = false
			yyq1036[0] = x.Backend != nil
			yyq1036[1] = len(x.TLS) != 0
			yyq1036[2] = len(x.Rules) != 0
			var yynn1036 int
			if yyr1036 || yy2arr1036 {
				r.EncodeArrayStart(3)
			} else {
				yynn1036 = 0
				for _, b := range yyq1036 {
					if b {
						yynn1036++
					}
				}
				r.EncodeMapStart(yynn1036)
				yynn1036 = 0
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1036[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("backend"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[1] {
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1039 := z.EncBinary()
						_ = yym1039
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1036[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("tls"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1040 := z.EncBinary()
						_ = yym1040
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1036[2] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1042 := z.EncBinary()
						_ = yym1042
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1036[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1043 := z.EncBinary()
						_ = yym1043
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr1036 || yy2arr1036 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1044 := z.DecBinary()
	_ = yym1044
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1045 := r.ContainerType()
		if yyct1045 == codecSelferValueTypeMap1234 {
			yyl1045 := r.ReadMapStart()
			if yyl1045 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1045, d)
			}
		} else if yyct1045 == codecSelferValueTypeArray1234 {
			yyl1045 := r.ReadArrayStart()
			if yyl1045 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1045, 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 yys1046Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1046Slc
	var yyhl1046 bool = l >= 0
	for yyj1046 := 0; ; yyj1046++ {
		if yyhl1046 {
			if yyj1046 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1046Slc = r.DecodeBytes(yys1046Slc, true, true)
		yys1046 := string(yys1046Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1046 {
		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 "tls":
			if r.TryDecodeAsNil() {
				x.TLS = nil
			} else {
				yyv1048 := &x.TLS
				yym1049 := z.DecBinary()
				_ = yym1049
				if false {
				} else {
					h.decSliceIngressTLS((*[]IngressTLS)(yyv1048), d)
				}
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv1050 := &x.Rules
				yym1051 := z.DecBinary()
				_ = yym1051
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv1050), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1046)
		} // end switch yys1046
	} // end for yyj1046
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1052 int
	var yyb1052 bool
	var yyhl1052 bool = l >= 0
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Backend != nil {
			x.Backend = nil
		}
	} else {
		if x.Backend == nil {
			x.Backend = new(IngressBackend)
		}
		x.Backend.CodecDecodeSelf(d)
	}
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TLS = nil
	} else {
		yyv1054 := &x.TLS
		yym1055 := z.DecBinary()
		_ = yym1055
		if false {
		} else {
			h.decSliceIngressTLS((*[]IngressTLS)(yyv1054), d)
		}
	}
	yyj1052++
	if yyhl1052 {
		yyb1052 = yyj1052 > l
	} else {
		yyb1052 = r.CheckBreak()
	}
	if yyb1052 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv1056 := &x.Rules
		yym1057 := z.DecBinary()
		_ = yym1057
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv1056), d)
		}
	}
	for {
		yyj1052++
		if yyhl1052 {
			yyb1052 = yyj1052 > l
		} else {
			yyb1052 = r.CheckBreak()
		}
		if yyb1052 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1052-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressTLS) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1058 := z.EncBinary()
		_ = yym1058
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1059 := !z.EncBinary()
			yy2arr1059 := z.EncBasicHandle().StructToArray
			var yyq1059 [2]bool
			_, _, _ = yysep1059, yyq1059, yy2arr1059
			const yyr1059 bool = false
			yyq1059[0] = len(x.Hosts) != 0
			yyq1059[1] = x.SecretName != ""
			var yynn1059 int
			if yyr1059 || yy2arr1059 {
				r.EncodeArrayStart(2)
			} else {
				yynn1059 = 0
				for _, b := range yyq1059 {
					if b {
						yynn1059++
					}
				}
				r.EncodeMapStart(yynn1059)
				yynn1059 = 0
			}
			if yyr1059 || yy2arr1059 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1059[0] {
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1061 := z.EncBinary()
						_ = yym1061
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1059[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hosts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1062 := z.EncBinary()
						_ = yym1062
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				}
			}
			if yyr1059 || yy2arr1059 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1059[1] {
					yym1064 := z.EncBinary()
					_ = yym1064
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1059[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("secretName"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1065 := z.EncBinary()
					_ = yym1065
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				}
			}
			if yyr1059 || yy2arr1059 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressTLS) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1066 := z.DecBinary()
	_ = yym1066
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1067 := r.ContainerType()
		if yyct1067 == codecSelferValueTypeMap1234 {
			yyl1067 := r.ReadMapStart()
			if yyl1067 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1067, d)
			}
		} else if yyct1067 == codecSelferValueTypeArray1234 {
			yyl1067 := r.ReadArrayStart()
			if yyl1067 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1067, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IngressTLS) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1068Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1068Slc
	var yyhl1068 bool = l >= 0
	for yyj1068 := 0; ; yyj1068++ {
		if yyhl1068 {
			if yyj1068 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1068Slc = r.DecodeBytes(yys1068Slc, true, true)
		yys1068 := string(yys1068Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1068 {
		case "hosts":
			if r.TryDecodeAsNil() {
				x.Hosts = nil
			} else {
				yyv1069 := &x.Hosts
				yym1070 := z.DecBinary()
				_ = yym1070
				if false {
				} else {
					z.F.DecSliceStringX(yyv1069, false, d)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1068)
		} // end switch yys1068
	} // end for yyj1068
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressTLS) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1072 int
	var yyb1072 bool
	var yyhl1072 bool = l >= 0
	yyj1072++
	if yyhl1072 {
		yyb1072 = yyj1072 > l
	} else {
		yyb1072 = r.CheckBreak()
	}
	if yyb1072 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Hosts = nil
	} else {
		yyv1073 := &x.Hosts
		yym1074 := z.DecBinary()
		_ = yym1074
		if false {
		} else {
			z.F.DecSliceStringX(yyv1073, false, d)
		}
	}
	yyj1072++
	if yyhl1072 {
		yyb1072 = yyj1072 > l
	} else {
		yyb1072 = r.CheckBreak()
	}
	if yyb1072 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	for {
		yyj1072++
		if yyhl1072 {
			yyb1072 = yyj1072 > l
		} else {
			yyb1072 = r.CheckBreak()
		}
		if yyb1072 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1072-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1076 := z.EncBinary()
		_ = yym1076
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1077 := !z.EncBinary()
			yy2arr1077 := z.EncBasicHandle().StructToArray
			var yyq1077 [1]bool
			_, _, _ = yysep1077, yyq1077, yy2arr1077
			const yyr1077 bool = false
			yyq1077[0] = true
			var yynn1077 int
			if yyr1077 || yy2arr1077 {
				r.EncodeArrayStart(1)
			} else {
				yynn1077 = 0
				for _, b := range yyq1077 {
					if b {
						yynn1077++
					}
				}
				r.EncodeMapStart(yynn1077)
				yynn1077 = 0
			}
			if yyr1077 || yy2arr1077 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1077[0] {
					yy1079 := &x.LoadBalancer
					yy1079.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1077[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1080 := &x.LoadBalancer
					yy1080.CodecEncodeSelf(e)
				}
			}
			if yyr1077 || yy2arr1077 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1081 := z.DecBinary()
	_ = yym1081
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1082 := r.ContainerType()
		if yyct1082 == codecSelferValueTypeMap1234 {
			yyl1082 := r.ReadMapStart()
			if yyl1082 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1082, d)
			}
		} else if yyct1082 == codecSelferValueTypeArray1234 {
			yyl1082 := r.ReadArrayStart()
			if yyl1082 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1082, 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 yys1083Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1083Slc
	var yyhl1083 bool = l >= 0
	for yyj1083 := 0; ; yyj1083++ {
		if yyhl1083 {
			if yyj1083 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1083Slc = r.DecodeBytes(yys1083Slc, true, true)
		yys1083 := string(yys1083Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1083 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
			} else {
				yyv1084 := &x.LoadBalancer
				yyv1084.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1083)
		} // end switch yys1083
	} // end for yyj1083
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1085 int
	var yyb1085 bool
	var yyhl1085 bool = l >= 0
	yyj1085++
	if yyhl1085 {
		yyb1085 = yyj1085 > l
	} else {
		yyb1085 = r.CheckBreak()
	}
	if yyb1085 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv1086 := &x.LoadBalancer
		yyv1086.CodecDecodeSelf(d)
	}
	for {
		yyj1085++
		if yyhl1085 {
			yyb1085 = yyj1085 > l
		} else {
			yyb1085 = r.CheckBreak()
		}
		if yyb1085 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1085-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1087 := z.EncBinary()
		_ = yym1087
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1088 := !z.EncBinary()
			yy2arr1088 := z.EncBasicHandle().StructToArray
			var yyq1088 [2]bool
			_, _, _ = yysep1088, yyq1088, yy2arr1088
			const yyr1088 bool = false
			yyq1088[0] = x.Host != ""
			yyq1088[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn1088 int
			if yyr1088 || yy2arr1088 {
				r.EncodeArrayStart(2)
			} else {
				yynn1088 = 0
				for _, b := range yyq1088 {
					if b {
						yynn1088++
					}
				}
				r.EncodeMapStart(yynn1088)
				yynn1088 = 0
			}
			if yyr1088 || yy2arr1088 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1088[0] {
					yym1090 := z.EncBinary()
					_ = yym1090
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1088[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1091 := z.EncBinary()
					_ = yym1091
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn1092 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn1092 = true
				goto LABEL1092
			}
		LABEL1092:
			if yyr1088 || yy2arr1088 {
				if yyn1092 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq1088[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq1088[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn1092 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr1088 || yy2arr1088 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1093 := z.DecBinary()
	_ = yym1093
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1094 := r.ContainerType()
		if yyct1094 == codecSelferValueTypeMap1234 {
			yyl1094 := r.ReadMapStart()
			if yyl1094 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1094, d)
			}
		} else if yyct1094 == codecSelferValueTypeArray1234 {
			yyl1094 := r.ReadArrayStart()
			if yyl1094 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1094, 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 yys1095Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1095Slc
	var yyhl1095 bool = l >= 0
	for yyj1095 := 0; ; yyj1095++ {
		if yyhl1095 {
			if yyj1095 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1095Slc = r.DecodeBytes(yys1095Slc, true, true)
		yys1095 := string(yys1095Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1095 {
		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, yys1095)
		} // end switch yys1095
	} // end for yyj1095
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1098 int
	var yyb1098 bool
	var yyhl1098 bool = l >= 0
	yyj1098++
	if yyhl1098 {
		yyb1098 = yyj1098 > l
	} else {
		yyb1098 = r.CheckBreak()
	}
	if yyb1098 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Host = ""
	} else {
		x.Host = string(r.DecodeString())
	}
	if x.IngressRuleValue.HTTP == nil {
		x.IngressRuleValue.HTTP = new(HTTPIngressRuleValue)
	}
	yyj1098++
	if yyhl1098 {
		yyb1098 = yyj1098 > l
	} else {
		yyb1098 = r.CheckBreak()
	}
	if yyb1098 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj1098++
		if yyhl1098 {
			yyb1098 = yyj1098 > l
		} else {
			yyb1098 = r.CheckBreak()
		}
		if yyb1098 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1098-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1101 := z.EncBinary()
		_ = yym1101
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1102 := !z.EncBinary()
			yy2arr1102 := z.EncBasicHandle().StructToArray
			var yyq1102 [1]bool
			_, _, _ = yysep1102, yyq1102, yy2arr1102
			const yyr1102 bool = false
			yyq1102[0] = x.HTTP != nil
			var yynn1102 int
			if yyr1102 || yy2arr1102 {
				r.EncodeArrayStart(1)
			} else {
				yynn1102 = 0
				for _, b := range yyq1102 {
					if b {
						yynn1102++
					}
				}
				r.EncodeMapStart(yynn1102)
				yynn1102 = 0
			}
			if yyr1102 || yy2arr1102 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1102[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1102[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1102 || yy2arr1102 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1104 := z.DecBinary()
	_ = yym1104
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1105 := r.ContainerType()
		if yyct1105 == codecSelferValueTypeMap1234 {
			yyl1105 := r.ReadMapStart()
			if yyl1105 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1105, d)
			}
		} else if yyct1105 == codecSelferValueTypeArray1234 {
			yyl1105 := r.ReadArrayStart()
			if yyl1105 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1105, 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 yys1106Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1106Slc
	var yyhl1106 bool = l >= 0
	for yyj1106 := 0; ; yyj1106++ {
		if yyhl1106 {
			if yyj1106 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1106Slc = r.DecodeBytes(yys1106Slc, true, true)
		yys1106 := string(yys1106Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1106 {
		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, yys1106)
		} // end switch yys1106
	} // end for yyj1106
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1108 int
	var yyb1108 bool
	var yyhl1108 bool = l >= 0
	yyj1108++
	if yyhl1108 {
		yyb1108 = yyj1108 > l
	} else {
		yyb1108 = r.CheckBreak()
	}
	if yyb1108 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.HTTP != nil {
			x.HTTP = nil
		}
	} else {
		if x.HTTP == nil {
			x.HTTP = new(HTTPIngressRuleValue)
		}
		x.HTTP.CodecDecodeSelf(d)
	}
	for {
		yyj1108++
		if yyhl1108 {
			yyb1108 = yyj1108 > l
		} else {
			yyb1108 = r.CheckBreak()
		}
		if yyb1108 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1108-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressRuleValue) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1110 := z.EncBinary()
		_ = yym1110
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1111 := !z.EncBinary()
			yy2arr1111 := z.EncBasicHandle().StructToArray
			var yyq1111 [1]bool
			_, _, _ = yysep1111, yyq1111, yy2arr1111
			const yyr1111 bool = false
			var yynn1111 int
			if yyr1111 || yy2arr1111 {
				r.EncodeArrayStart(1)
			} else {
				yynn1111 = 1
				for _, b := range yyq1111 {
					if b {
						yynn1111++
					}
				}
				r.EncodeMapStart(yynn1111)
				yynn1111 = 0
			}
			if yyr1111 || yy2arr1111 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym1113 := z.EncBinary()
					_ = yym1113
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("paths"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym1114 := z.EncBinary()
					_ = yym1114
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr1111 || yy2arr1111 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressRuleValue) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1115 := z.DecBinary()
	_ = yym1115
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1116 := r.ContainerType()
		if yyct1116 == codecSelferValueTypeMap1234 {
			yyl1116 := r.ReadMapStart()
			if yyl1116 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1116, d)
			}
		} else if yyct1116 == codecSelferValueTypeArray1234 {
			yyl1116 := r.ReadArrayStart()
			if yyl1116 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1116, 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 yys1117Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1117Slc
	var yyhl1117 bool = l >= 0
	for yyj1117 := 0; ; yyj1117++ {
		if yyhl1117 {
			if yyj1117 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1117Slc = r.DecodeBytes(yys1117Slc, true, true)
		yys1117 := string(yys1117Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1117 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv1118 := &x.Paths
				yym1119 := z.DecBinary()
				_ = yym1119
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1118), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1117)
		} // end switch yys1117
	} // end for yyj1117
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressRuleValue) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1120 int
	var yyb1120 bool
	var yyhl1120 bool = l >= 0
	yyj1120++
	if yyhl1120 {
		yyb1120 = yyj1120 > l
	} else {
		yyb1120 = r.CheckBreak()
	}
	if yyb1120 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv1121 := &x.Paths
		yym1122 := z.DecBinary()
		_ = yym1122
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1121), d)
		}
	}
	for {
		yyj1120++
		if yyhl1120 {
			yyb1120 = yyj1120 > l
		} else {
			yyb1120 = r.CheckBreak()
		}
		if yyb1120 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1120-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HTTPIngressPath) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1123 := z.EncBinary()
		_ = yym1123
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1124 := !z.EncBinary()
			yy2arr1124 := z.EncBasicHandle().StructToArray
			var yyq1124 [2]bool
			_, _, _ = yysep1124, yyq1124, yy2arr1124
			const yyr1124 bool = false
			yyq1124[0] = x.Path != ""
			var yynn1124 int
			if yyr1124 || yy2arr1124 {
				r.EncodeArrayStart(2)
			} else {
				yynn1124 = 1
				for _, b := range yyq1124 {
					if b {
						yynn1124++
					}
				}
				r.EncodeMapStart(yynn1124)
				yynn1124 = 0
			}
			if yyr1124 || yy2arr1124 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1124[0] {
					yym1126 := z.EncBinary()
					_ = yym1126
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1124[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1127 := z.EncBinary()
					_ = yym1127
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr1124 || yy2arr1124 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1129 := &x.Backend
				yy1129.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1130 := &x.Backend
				yy1130.CodecEncodeSelf(e)
			}
			if yyr1124 || yy2arr1124 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HTTPIngressPath) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1131 := z.DecBinary()
	_ = yym1131
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1132 := r.ContainerType()
		if yyct1132 == codecSelferValueTypeMap1234 {
			yyl1132 := r.ReadMapStart()
			if yyl1132 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1132, d)
			}
		} else if yyct1132 == codecSelferValueTypeArray1234 {
			yyl1132 := r.ReadArrayStart()
			if yyl1132 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1132, 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 yys1133Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1133Slc
	var yyhl1133 bool = l >= 0
	for yyj1133 := 0; ; yyj1133++ {
		if yyhl1133 {
			if yyj1133 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1133Slc = r.DecodeBytes(yys1133Slc, true, true)
		yys1133 := string(yys1133Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1133 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv1135 := &x.Backend
				yyv1135.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1133)
		} // end switch yys1133
	} // end for yyj1133
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HTTPIngressPath) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1136 int
	var yyb1136 bool
	var yyhl1136 bool = l >= 0
	yyj1136++
	if yyhl1136 {
		yyb1136 = yyj1136 > l
	} else {
		yyb1136 = r.CheckBreak()
	}
	if yyb1136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj1136++
	if yyhl1136 {
		yyb1136 = yyj1136 > l
	} else {
		yyb1136 = r.CheckBreak()
	}
	if yyb1136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv1138 := &x.Backend
		yyv1138.CodecDecodeSelf(d)
	}
	for {
		yyj1136++
		if yyhl1136 {
			yyb1136 = yyj1136 > l
		} else {
			yyb1136 = r.CheckBreak()
		}
		if yyb1136 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1136-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IngressBackend) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1139 := z.EncBinary()
		_ = yym1139
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1140 := !z.EncBinary()
			yy2arr1140 := z.EncBasicHandle().StructToArray
			var yyq1140 [2]bool
			_, _, _ = yysep1140, yyq1140, yy2arr1140
			const yyr1140 bool = false
			var yynn1140 int
			if yyr1140 || yy2arr1140 {
				r.EncodeArrayStart(2)
			} else {
				yynn1140 = 2
				for _, b := range yyq1140 {
					if b {
						yynn1140++
					}
				}
				r.EncodeMapStart(yynn1140)
				yynn1140 = 0
			}
			if yyr1140 || yy2arr1140 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1142 := z.EncBinary()
				_ = yym1142
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("serviceName"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1143 := z.EncBinary()
				_ = yym1143
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr1140 || yy2arr1140 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1145 := &x.ServicePort
				yym1146 := z.EncBinary()
				_ = yym1146
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1145) {
				} else if !yym1146 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1145)
				} else {
					z.EncFallback(yy1145)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1147 := &x.ServicePort
				yym1148 := z.EncBinary()
				_ = yym1148
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1147) {
				} else if !yym1148 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1147)
				} else {
					z.EncFallback(yy1147)
				}
			}
			if yyr1140 || yy2arr1140 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IngressBackend) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1149 := z.DecBinary()
	_ = yym1149
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1150 := r.ContainerType()
		if yyct1150 == codecSelferValueTypeMap1234 {
			yyl1150 := r.ReadMapStart()
			if yyl1150 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1150, d)
			}
		} else if yyct1150 == codecSelferValueTypeArray1234 {
			yyl1150 := r.ReadArrayStart()
			if yyl1150 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1150, 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 yys1151Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1151Slc
	var yyhl1151 bool = l >= 0
	for yyj1151 := 0; ; yyj1151++ {
		if yyhl1151 {
			if yyj1151 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1151Slc = r.DecodeBytes(yys1151Slc, true, true)
		yys1151 := string(yys1151Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1151 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg5_intstr.IntOrString{}
			} else {
				yyv1153 := &x.ServicePort
				yym1154 := z.DecBinary()
				_ = yym1154
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1153) {
				} else if !yym1154 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1153)
				} else {
					z.DecFallback(yyv1153, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1151)
		} // end switch yys1151
	} // end for yyj1151
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IngressBackend) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1155 int
	var yyb1155 bool
	var yyhl1155 bool = l >= 0
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj1155++
	if yyhl1155 {
		yyb1155 = yyj1155 > l
	} else {
		yyb1155 = r.CheckBreak()
	}
	if yyb1155 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg5_intstr.IntOrString{}
	} else {
		yyv1157 := &x.ServicePort
		yym1158 := z.DecBinary()
		_ = yym1158
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1157) {
		} else if !yym1158 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1157)
		} else {
			z.DecFallback(yyv1157, false)
		}
	}
	for {
		yyj1155++
		if yyhl1155 {
			yyb1155 = yyj1155 > l
		} else {
			yyb1155 = r.CheckBreak()
		}
		if yyb1155 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1155-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1159 := z.EncBinary()
		_ = yym1159
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1160 := !z.EncBinary()
			yy2arr1160 := z.EncBasicHandle().StructToArray
			var yyq1160 [4]bool
			_, _, _ = yysep1160, yyq1160, yy2arr1160
			const yyr1160 bool = false
			yyq1160[0] = x.Kind != ""
			yyq1160[1] = x.APIVersion != ""
			var yynn1160 int
			if yyr1160 || yy2arr1160 {
				r.EncodeArrayStart(4)
			} else {
				yynn1160 = 2
				for _, b := range yyq1160 {
					if b {
						yynn1160++
					}
				}
				r.EncodeMapStart(yynn1160)
				yynn1160 = 0
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1160[0] {
					yym1162 := z.EncBinary()
					_ = yym1162
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1160[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1163 := z.EncBinary()
					_ = yym1163
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1160[1] {
					yym1165 := z.EncBinary()
					_ = yym1165
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1160[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1166 := z.EncBinary()
					_ = yym1166
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1168 := z.EncBinary()
				_ = yym1168
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("export"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1169 := z.EncBinary()
				_ = yym1169
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1171 := z.EncBinary()
				_ = yym1171
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("exact"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1172 := z.EncBinary()
				_ = yym1172
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ExportOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1173 := z.DecBinary()
	_ = yym1173
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1174 := r.ContainerType()
		if yyct1174 == codecSelferValueTypeMap1234 {
			yyl1174 := r.ReadMapStart()
			if yyl1174 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1174, d)
			}
		} else if yyct1174 == codecSelferValueTypeArray1234 {
			yyl1174 := r.ReadArrayStart()
			if yyl1174 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1174, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1175Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1175Slc
	var yyhl1175 bool = l >= 0
	for yyj1175 := 0; ; yyj1175++ {
		if yyhl1175 {
			if yyj1175 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1175Slc = r.DecodeBytes(yys1175Slc, true, true)
		yys1175 := string(yys1175Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1175 {
		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 "export":
			if r.TryDecodeAsNil() {
				x.Export = false
			} else {
				x.Export = bool(r.DecodeBool())
			}
		case "exact":
			if r.TryDecodeAsNil() {
				x.Exact = false
			} else {
				x.Exact = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1175)
		} // end switch yys1175
	} // end for yyj1175
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1180 int
	var yyb1180 bool
	var yyhl1180 bool = l >= 0
	yyj1180++
	if yyhl1180 {
		yyb1180 = yyj1180 > l
	} else {
		yyb1180 = r.CheckBreak()
	}
	if yyb1180 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1180++
	if yyhl1180 {
		yyb1180 = yyj1180 > l
	} else {
		yyb1180 = r.CheckBreak()
	}
	if yyb1180 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1180++
	if yyhl1180 {
		yyb1180 = yyj1180 > l
	} else {
		yyb1180 = r.CheckBreak()
	}
	if yyb1180 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Export = false
	} else {
		x.Export = bool(r.DecodeBool())
	}
	yyj1180++
	if yyhl1180 {
		yyb1180 = yyj1180 > l
	} else {
		yyb1180 = r.CheckBreak()
	}
	if yyb1180 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Exact = false
	} else {
		x.Exact = bool(r.DecodeBool())
	}
	for {
		yyj1180++
		if yyhl1180 {
			yyb1180 = yyj1180 > l
		} else {
			yyb1180 = r.CheckBreak()
		}
		if yyb1180 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1180-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *LabelSelector) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1185 := z.EncBinary()
		_ = yym1185
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1186 := !z.EncBinary()
			yy2arr1186 := z.EncBasicHandle().StructToArray
			var yyq1186 [2]bool
			_, _, _ = yysep1186, yyq1186, yy2arr1186
			const yyr1186 bool = false
			yyq1186[0] = len(x.MatchLabels) != 0
			yyq1186[1] = len(x.MatchExpressions) != 0
			var yynn1186 int
			if yyr1186 || yy2arr1186 {
				r.EncodeArrayStart(2)
			} else {
				yynn1186 = 0
				for _, b := range yyq1186 {
					if b {
						yynn1186++
					}
				}
				r.EncodeMapStart(yynn1186)
				yynn1186 = 0
			}
			if yyr1186 || yy2arr1186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1186[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1188 := z.EncBinary()
						_ = yym1188
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1186[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1189 := z.EncBinary()
						_ = yym1189
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1186 || yy2arr1186 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1186[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1191 := z.EncBinary()
						_ = yym1191
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1186[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1192 := z.EncBinary()
						_ = yym1192
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yyr1186 || yy2arr1186 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *LabelSelector) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1193 := z.DecBinary()
	_ = yym1193
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1194 := r.ContainerType()
		if yyct1194 == codecSelferValueTypeMap1234 {
			yyl1194 := r.ReadMapStart()
			if yyl1194 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1194, d)
			}
		} else if yyct1194 == codecSelferValueTypeArray1234 {
			yyl1194 := r.ReadArrayStart()
			if yyl1194 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1194, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *LabelSelector) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1195Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1195Slc
	var yyhl1195 bool = l >= 0
	for yyj1195 := 0; ; yyj1195++ {
		if yyhl1195 {
			if yyj1195 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1195Slc = r.DecodeBytes(yys1195Slc, true, true)
		yys1195 := string(yys1195Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1195 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1196 := &x.MatchLabels
				yym1197 := z.DecBinary()
				_ = yym1197
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1196, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1198 := &x.MatchExpressions
				yym1199 := z.DecBinary()
				_ = yym1199
				if false {
				} else {
					h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1198), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1195)
		} // end switch yys1195
	} // end for yyj1195
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *LabelSelector) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1200 int
	var yyb1200 bool
	var yyhl1200 bool = l >= 0
	yyj1200++
	if yyhl1200 {
		yyb1200 = yyj1200 > l
	} else {
		yyb1200 = r.CheckBreak()
	}
	if yyb1200 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1201 := &x.MatchLabels
		yym1202 := z.DecBinary()
		_ = yym1202
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1201, false, d)
		}
	}
	yyj1200++
	if yyhl1200 {
		yyb1200 = yyj1200 > l
	} else {
		yyb1200 = r.CheckBreak()
	}
	if yyb1200 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1203 := &x.MatchExpressions
		yym1204 := z.DecBinary()
		_ = yym1204
		if false {
		} else {
			h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1203), d)
		}
	}
	for {
		yyj1200++
		if yyhl1200 {
			yyb1200 = yyj1200 > l
		} else {
			yyb1200 = r.CheckBreak()
		}
		if yyb1200 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1200-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *LabelSelectorRequirement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1205 := z.EncBinary()
		_ = yym1205
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1206 := !z.EncBinary()
			yy2arr1206 := z.EncBasicHandle().StructToArray
			var yyq1206 [3]bool
			_, _, _ = yysep1206, yyq1206, yy2arr1206
			const yyr1206 bool = false
			yyq1206[2] = len(x.Values) != 0
			var yynn1206 int
			if yyr1206 || yy2arr1206 {
				r.EncodeArrayStart(3)
			} else {
				yynn1206 = 2
				for _, b := range yyq1206 {
					if b {
						yynn1206++
					}
				}
				r.EncodeMapStart(yynn1206)
				yynn1206 = 0
			}
			if yyr1206 || yy2arr1206 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1208 := z.EncBinary()
				_ = yym1208
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("key"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1209 := z.EncBinary()
				_ = yym1209
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1206 || yy2arr1206 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Operator.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("operator"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Operator.CodecEncodeSelf(e)
			}
			if yyr1206 || yy2arr1206 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1206[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1212 := z.EncBinary()
						_ = yym1212
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1206[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1213 := z.EncBinary()
						_ = yym1213
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yyr1206 || yy2arr1206 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *LabelSelectorRequirement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1214 := z.DecBinary()
	_ = yym1214
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1215 := r.ContainerType()
		if yyct1215 == codecSelferValueTypeMap1234 {
			yyl1215 := r.ReadMapStart()
			if yyl1215 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1215, d)
			}
		} else if yyct1215 == codecSelferValueTypeArray1234 {
			yyl1215 := r.ReadArrayStart()
			if yyl1215 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1215, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *LabelSelectorRequirement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1216Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1216Slc
	var yyhl1216 bool = l >= 0
	for yyj1216 := 0; ; yyj1216++ {
		if yyhl1216 {
			if yyj1216 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1216Slc = r.DecodeBytes(yys1216Slc, true, true)
		yys1216 := string(yys1216Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1216 {
		case "key":
			if r.TryDecodeAsNil() {
				x.Key = ""
			} else {
				x.Key = string(r.DecodeString())
			}
		case "operator":
			if r.TryDecodeAsNil() {
				x.Operator = ""
			} else {
				x.Operator = LabelSelectorOperator(r.DecodeString())
			}
		case "values":
			if r.TryDecodeAsNil() {
				x.Values = nil
			} else {
				yyv1219 := &x.Values
				yym1220 := z.DecBinary()
				_ = yym1220
				if false {
				} else {
					z.F.DecSliceStringX(yyv1219, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1216)
		} // end switch yys1216
	} // end for yyj1216
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *LabelSelectorRequirement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1221 int
	var yyb1221 bool
	var yyhl1221 bool = l >= 0
	yyj1221++
	if yyhl1221 {
		yyb1221 = yyj1221 > l
	} else {
		yyb1221 = r.CheckBreak()
	}
	if yyb1221 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1221++
	if yyhl1221 {
		yyb1221 = yyj1221 > l
	} else {
		yyb1221 = r.CheckBreak()
	}
	if yyb1221 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = LabelSelectorOperator(r.DecodeString())
	}
	yyj1221++
	if yyhl1221 {
		yyb1221 = yyj1221 > l
	} else {
		yyb1221 = r.CheckBreak()
	}
	if yyb1221 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1224 := &x.Values
		yym1225 := z.DecBinary()
		_ = yym1225
		if false {
		} else {
			z.F.DecSliceStringX(yyv1224, false, d)
		}
	}
	for {
		yyj1221++
		if yyhl1221 {
			yyb1221 = yyj1221 > l
		} else {
			yyb1221 = r.CheckBreak()
		}
		if yyb1221 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1221-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1226 := z.EncBinary()
	_ = yym1226
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *LabelSelectorOperator) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1227 := z.DecBinary()
	_ = yym1227
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1228 := z.EncBinary()
		_ = yym1228
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1229 := !z.EncBinary()
			yy2arr1229 := z.EncBasicHandle().StructToArray
			var yyq1229 [5]bool
			_, _, _ = yysep1229, yyq1229, yy2arr1229
			const yyr1229 bool = false
			yyq1229[0] = x.Kind != ""
			yyq1229[1] = x.APIVersion != ""
			yyq1229[2] = true
			yyq1229[3] = true
			yyq1229[4] = true
			var yynn1229 int
			if yyr1229 || yy2arr1229 {
				r.EncodeArrayStart(5)
			} else {
				yynn1229 = 0
				for _, b := range yyq1229 {
					if b {
						yynn1229++
					}
				}
				r.EncodeMapStart(yynn1229)
				yynn1229 = 0
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[0] {
					yym1231 := z.EncBinary()
					_ = yym1231
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1229[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1232 := z.EncBinary()
					_ = yym1232
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[1] {
					yym1234 := z.EncBinary()
					_ = yym1234
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1229[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1235 := z.EncBinary()
					_ = yym1235
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[2] {
					yy1237 := &x.ObjectMeta
					yy1237.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1229[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1238 := &x.ObjectMeta
					yy1238.CodecEncodeSelf(e)
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[3] {
					yy1240 := &x.Spec
					yy1240.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1229[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1241 := &x.Spec
					yy1241.CodecEncodeSelf(e)
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1229[4] {
					yy1243 := &x.Status
					yy1243.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1229[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1244 := &x.Status
					yy1244.CodecEncodeSelf(e)
				}
			}
			if yyr1229 || yy2arr1229 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSet) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1245 := z.DecBinary()
	_ = yym1245
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1246 := r.ContainerType()
		if yyct1246 == codecSelferValueTypeMap1234 {
			yyl1246 := r.ReadMapStart()
			if yyl1246 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1246, d)
			}
		} else if yyct1246 == codecSelferValueTypeArray1234 {
			yyl1246 := r.ReadArrayStart()
			if yyl1246 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1246, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSet) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1247Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1247Slc
	var yyhl1247 bool = l >= 0
	for yyj1247 := 0; ; yyj1247++ {
		if yyhl1247 {
			if yyj1247 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1247Slc = r.DecodeBytes(yys1247Slc, true, true)
		yys1247 := string(yys1247Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1247 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1250 := &x.ObjectMeta
				yyv1250.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv1251 := &x.Spec
				yyv1251.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv1252 := &x.Status
				yyv1252.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1247)
		} // end switch yys1247
	} // end for yyj1247
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSet) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1253 int
	var yyb1253 bool
	var yyhl1253 bool = l >= 0
	yyj1253++
	if yyhl1253 {
		yyb1253 = yyj1253 > l
	} else {
		yyb1253 = r.CheckBreak()
	}
	if yyb1253 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1253++
	if yyhl1253 {
		yyb1253 = yyj1253 > l
	} else {
		yyb1253 = r.CheckBreak()
	}
	if yyb1253 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1253++
	if yyhl1253 {
		yyb1253 = yyj1253 > l
	} else {
		yyb1253 = r.CheckBreak()
	}
	if yyb1253 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1256 := &x.ObjectMeta
		yyv1256.CodecDecodeSelf(d)
	}
	yyj1253++
	if yyhl1253 {
		yyb1253 = yyj1253 > l
	} else {
		yyb1253 = r.CheckBreak()
	}
	if yyb1253 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv1257 := &x.Spec
		yyv1257.CodecDecodeSelf(d)
	}
	yyj1253++
	if yyhl1253 {
		yyb1253 = yyj1253 > l
	} else {
		yyb1253 = r.CheckBreak()
	}
	if yyb1253 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv1258 := &x.Status
		yyv1258.CodecDecodeSelf(d)
	}
	for {
		yyj1253++
		if yyhl1253 {
			yyb1253 = yyj1253 > l
		} else {
			yyb1253 = r.CheckBreak()
		}
		if yyb1253 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1253-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1259 := z.EncBinary()
		_ = yym1259
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1260 := !z.EncBinary()
			yy2arr1260 := z.EncBasicHandle().StructToArray
			var yyq1260 [4]bool
			_, _, _ = yysep1260, yyq1260, yy2arr1260
			const yyr1260 bool = false
			yyq1260[0] = x.Kind != ""
			yyq1260[1] = x.APIVersion != ""
			yyq1260[2] = true
			var yynn1260 int
			if yyr1260 || yy2arr1260 {
				r.EncodeArrayStart(4)
			} else {
				yynn1260 = 1
				for _, b := range yyq1260 {
					if b {
						yynn1260++
					}
				}
				r.EncodeMapStart(yynn1260)
				yynn1260 = 0
			}
			if yyr1260 || yy2arr1260 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1260[0] {
					yym1262 := z.EncBinary()
					_ = yym1262
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1260[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1263 := z.EncBinary()
					_ = yym1263
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1260 || yy2arr1260 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1260[1] {
					yym1265 := z.EncBinary()
					_ = yym1265
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1260[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1266 := z.EncBinary()
					_ = yym1266
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1260 || yy2arr1260 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1260[2] {
					yy1268 := &x.ListMeta
					yym1269 := z.EncBinary()
					_ = yym1269
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1268) {
					} else {
						z.EncFallback(yy1268)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1260[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1270 := &x.ListMeta
					yym1271 := z.EncBinary()
					_ = yym1271
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1270) {
					} else {
						z.EncFallback(yy1270)
					}
				}
			}
			if yyr1260 || yy2arr1260 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1273 := z.EncBinary()
					_ = yym1273
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1274 := z.EncBinary()
					_ = yym1274
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr1260 || yy2arr1260 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1275 := z.DecBinary()
	_ = yym1275
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1276 := r.ContainerType()
		if yyct1276 == codecSelferValueTypeMap1234 {
			yyl1276 := r.ReadMapStart()
			if yyl1276 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1276, d)
			}
		} else if yyct1276 == codecSelferValueTypeArray1234 {
			yyl1276 := r.ReadArrayStart()
			if yyl1276 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1276, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1277Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1277Slc
	var yyhl1277 bool = l >= 0
	for yyj1277 := 0; ; yyj1277++ {
		if yyhl1277 {
			if yyj1277 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1277Slc = r.DecodeBytes(yys1277Slc, true, true)
		yys1277 := string(yys1277Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1277 {
		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 {
				yyv1280 := &x.ListMeta
				yym1281 := z.DecBinary()
				_ = yym1281
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1280) {
				} else {
					z.DecFallback(yyv1280, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1282 := &x.Items
				yym1283 := z.DecBinary()
				_ = yym1283
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv1282), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1277)
		} // end switch yys1277
	} // end for yyj1277
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1284 int
	var yyb1284 bool
	var yyhl1284 bool = l >= 0
	yyj1284++
	if yyhl1284 {
		yyb1284 = yyj1284 > l
	} else {
		yyb1284 = r.CheckBreak()
	}
	if yyb1284 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1284++
	if yyhl1284 {
		yyb1284 = yyj1284 > l
	} else {
		yyb1284 = r.CheckBreak()
	}
	if yyb1284 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1284++
	if yyhl1284 {
		yyb1284 = yyj1284 > l
	} else {
		yyb1284 = r.CheckBreak()
	}
	if yyb1284 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1287 := &x.ListMeta
		yym1288 := z.DecBinary()
		_ = yym1288
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1287) {
		} else {
			z.DecFallback(yyv1287, false)
		}
	}
	yyj1284++
	if yyhl1284 {
		yyb1284 = yyj1284 > l
	} else {
		yyb1284 = r.CheckBreak()
	}
	if yyb1284 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1289 := &x.Items
		yym1290 := z.DecBinary()
		_ = yym1290
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv1289), d)
		}
	}
	for {
		yyj1284++
		if yyhl1284 {
			yyb1284 = yyj1284 > l
		} else {
			yyb1284 = r.CheckBreak()
		}
		if yyb1284 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1284-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1291 := z.EncBinary()
		_ = yym1291
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1292 := !z.EncBinary()
			yy2arr1292 := z.EncBasicHandle().StructToArray
			var yyq1292 [4]bool
			_, _, _ = yysep1292, yyq1292, yy2arr1292
			const yyr1292 bool = false
			yyq1292[0] = x.Replicas != nil
			yyq1292[1] = x.MinReadySeconds != 0
			yyq1292[2] = x.Selector != nil
			yyq1292[3] = true
			var yynn1292 int
			if yyr1292 || yy2arr1292 {
				r.EncodeArrayStart(4)
			} else {
				yynn1292 = 0
				for _, b := range yyq1292 {
					if b {
						yynn1292++
					}
				}
				r.EncodeMapStart(yynn1292)
				yynn1292 = 0
			}
			if yyr1292 || yy2arr1292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1292[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1294 := *x.Replicas
						yym1295 := z.EncBinary()
						_ = yym1295
						if false {
						} else {
							r.EncodeInt(int64(yy1294))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1292[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1296 := *x.Replicas
						yym1297 := z.EncBinary()
						_ = yym1297
						if false {
						} else {
							r.EncodeInt(int64(yy1296))
						}
					}
				}
			}
			if yyr1292 || yy2arr1292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1292[1] {
					yym1299 := z.EncBinary()
					_ = yym1299
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1292[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1300 := z.EncBinary()
					_ = yym1300
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr1292 || yy2arr1292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1292[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1292[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1292 || yy2arr1292 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1292[3] {
					yy1303 := &x.Template
					yy1303.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1292[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1304 := &x.Template
					yy1304.CodecEncodeSelf(e)
				}
			}
			if yyr1292 || yy2arr1292 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1305 := z.DecBinary()
	_ = yym1305
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1306 := r.ContainerType()
		if yyct1306 == codecSelferValueTypeMap1234 {
			yyl1306 := r.ReadMapStart()
			if yyl1306 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1306, d)
			}
		} else if yyct1306 == codecSelferValueTypeArray1234 {
			yyl1306 := r.ReadArrayStart()
			if yyl1306 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1306, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1307Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1307Slc
	var yyhl1307 bool = l >= 0
	for yyj1307 := 0; ; yyj1307++ {
		if yyhl1307 {
			if yyj1307 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1307Slc = r.DecodeBytes(yys1307Slc, true, true)
		yys1307 := string(yys1307Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1307 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym1309 := z.DecBinary()
				_ = yym1309
				if false {
				} else {
					*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
				}
			}
		case "minReadySeconds":
			if r.TryDecodeAsNil() {
				x.MinReadySeconds = 0
			} else {
				x.MinReadySeconds = int32(r.DecodeInt(32))
			}
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(LabelSelector)
				}
				x.Selector.CodecDecodeSelf(d)
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv1312 := &x.Template
				yyv1312.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1307)
		} // end switch yys1307
	} // end for yyj1307
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1313 int
	var yyb1313 bool
	var yyhl1313 bool = l >= 0
	yyj1313++
	if yyhl1313 {
		yyb1313 = yyj1313 > l
	} else {
		yyb1313 = r.CheckBreak()
	}
	if yyb1313 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Replicas != nil {
			x.Replicas = nil
		}
	} else {
		if x.Replicas == nil {
			x.Replicas = new(int32)
		}
		yym1315 := z.DecBinary()
		_ = yym1315
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj1313++
	if yyhl1313 {
		yyb1313 = yyj1313 > l
	} else {
		yyb1313 = r.CheckBreak()
	}
	if yyb1313 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj1313++
	if yyhl1313 {
		yyb1313 = yyj1313 > l
	} else {
		yyb1313 = r.CheckBreak()
	}
	if yyb1313 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Selector != nil {
			x.Selector = nil
		}
	} else {
		if x.Selector == nil {
			x.Selector = new(LabelSelector)
		}
		x.Selector.CodecDecodeSelf(d)
	}
	yyj1313++
	if yyhl1313 {
		yyb1313 = yyj1313 > l
	} else {
		yyb1313 = r.CheckBreak()
	}
	if yyb1313 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv1318 := &x.Template
		yyv1318.CodecDecodeSelf(d)
	}
	for {
		yyj1313++
		if yyhl1313 {
			yyb1313 = yyj1313 > l
		} else {
			yyb1313 = r.CheckBreak()
		}
		if yyb1313 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1313-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSetStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1319 := z.EncBinary()
		_ = yym1319
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1320 := !z.EncBinary()
			yy2arr1320 := z.EncBasicHandle().StructToArray
			var yyq1320 [5]bool
			_, _, _ = yysep1320, yyq1320, yy2arr1320
			const yyr1320 bool = false
			yyq1320[1] = x.FullyLabeledReplicas != 0
			yyq1320[2] = x.ReadyReplicas != 0
			yyq1320[3] = x.AvailableReplicas != 0
			yyq1320[4] = x.ObservedGeneration != 0
			var yynn1320 int
			if yyr1320 || yy2arr1320 {
				r.EncodeArrayStart(5)
			} else {
				yynn1320 = 1
				for _, b := range yyq1320 {
					if b {
						yynn1320++
					}
				}
				r.EncodeMapStart(yynn1320)
				yynn1320 = 0
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1322 := z.EncBinary()
				_ = yym1322
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1323 := z.EncBinary()
				_ = yym1323
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1320[1] {
					yym1325 := z.EncBinary()
					_ = yym1325
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1320[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1326 := z.EncBinary()
					_ = yym1326
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				}
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1320[2] {
					yym1328 := z.EncBinary()
					_ = yym1328
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1320[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1329 := z.EncBinary()
					_ = yym1329
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				}
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1320[3] {
					yym1331 := z.EncBinary()
					_ = yym1331
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1320[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1332 := z.EncBinary()
					_ = yym1332
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1320[4] {
					yym1334 := z.EncBinary()
					_ = yym1334
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1320[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1335 := z.EncBinary()
					_ = yym1335
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr1320 || yy2arr1320 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ReplicaSetStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1336 := z.DecBinary()
	_ = yym1336
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1337 := r.ContainerType()
		if yyct1337 == codecSelferValueTypeMap1234 {
			yyl1337 := r.ReadMapStart()
			if yyl1337 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1337, d)
			}
		} else if yyct1337 == codecSelferValueTypeArray1234 {
			yyl1337 := r.ReadArrayStart()
			if yyl1337 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1337, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicaSetStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1338Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1338Slc
	var yyhl1338 bool = l >= 0
	for yyj1338 := 0; ; yyj1338++ {
		if yyhl1338 {
			if yyj1338 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1338Slc = r.DecodeBytes(yys1338Slc, true, true)
		yys1338 := string(yys1338Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1338 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				x.Replicas = int32(r.DecodeInt(32))
			}
		case "fullyLabeledReplicas":
			if r.TryDecodeAsNil() {
				x.FullyLabeledReplicas = 0
			} else {
				x.FullyLabeledReplicas = int32(r.DecodeInt(32))
			}
		case "readyReplicas":
			if r.TryDecodeAsNil() {
				x.ReadyReplicas = 0
			} else {
				x.ReadyReplicas = int32(r.DecodeInt(32))
			}
		case "availableReplicas":
			if r.TryDecodeAsNil() {
				x.AvailableReplicas = 0
			} else {
				x.AvailableReplicas = int32(r.DecodeInt(32))
			}
		case "observedGeneration":
			if r.TryDecodeAsNil() {
				x.ObservedGeneration = 0
			} else {
				x.ObservedGeneration = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1338)
		} // end switch yys1338
	} // end for yyj1338
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1344 int
	var yyb1344 bool
	var yyhl1344 bool = l >= 0
	yyj1344++
	if yyhl1344 {
		yyb1344 = yyj1344 > l
	} else {
		yyb1344 = r.CheckBreak()
	}
	if yyb1344 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj1344++
	if yyhl1344 {
		yyb1344 = yyj1344 > l
	} else {
		yyb1344 = r.CheckBreak()
	}
	if yyb1344 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FullyLabeledReplicas = 0
	} else {
		x.FullyLabeledReplicas = int32(r.DecodeInt(32))
	}
	yyj1344++
	if yyhl1344 {
		yyb1344 = yyj1344 > l
	} else {
		yyb1344 = r.CheckBreak()
	}
	if yyb1344 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadyReplicas = 0
	} else {
		x.ReadyReplicas = int32(r.DecodeInt(32))
	}
	yyj1344++
	if yyhl1344 {
		yyb1344 = yyj1344 > l
	} else {
		yyb1344 = r.CheckBreak()
	}
	if yyb1344 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj1344++
	if yyhl1344 {
		yyb1344 = yyj1344 > l
	} else {
		yyb1344 = r.CheckBreak()
	}
	if yyb1344 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	for {
		yyj1344++
		if yyhl1344 {
			yyb1344 = yyj1344 > l
		} else {
			yyb1344 = r.CheckBreak()
		}
		if yyb1344 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1344-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1350 := z.EncBinary()
		_ = yym1350
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1351 := !z.EncBinary()
			yy2arr1351 := z.EncBasicHandle().StructToArray
			var yyq1351 [4]bool
			_, _, _ = yysep1351, yyq1351, yy2arr1351
			const yyr1351 bool = false
			yyq1351[0] = x.Kind != ""
			yyq1351[1] = x.APIVersion != ""
			yyq1351[2] = true
			yyq1351[3] = true
			var yynn1351 int
			if yyr1351 || yy2arr1351 {
				r.EncodeArrayStart(4)
			} else {
				yynn1351 = 0
				for _, b := range yyq1351 {
					if b {
						yynn1351++
					}
				}
				r.EncodeMapStart(yynn1351)
				yynn1351 = 0
			}
			if yyr1351 || yy2arr1351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1351[0] {
					yym1353 := z.EncBinary()
					_ = yym1353
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1351[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1354 := z.EncBinary()
					_ = yym1354
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1351 || yy2arr1351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1351[1] {
					yym1356 := z.EncBinary()
					_ = yym1356
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1351[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1357 := z.EncBinary()
					_ = yym1357
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1351 || yy2arr1351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1351[2] {
					yy1359 := &x.ObjectMeta
					yy1359.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1351[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1360 := &x.ObjectMeta
					yy1360.CodecEncodeSelf(e)
				}
			}
			if yyr1351 || yy2arr1351 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1351[3] {
					yy1362 := &x.Spec
					yy1362.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1351[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1363 := &x.Spec
					yy1363.CodecEncodeSelf(e)
				}
			}
			if yyr1351 || yy2arr1351 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1364 := z.DecBinary()
	_ = yym1364
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1365 := r.ContainerType()
		if yyct1365 == codecSelferValueTypeMap1234 {
			yyl1365 := r.ReadMapStart()
			if yyl1365 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1365, d)
			}
		} else if yyct1365 == codecSelferValueTypeArray1234 {
			yyl1365 := r.ReadArrayStart()
			if yyl1365 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1365, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1366Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1366Slc
	var yyhl1366 bool = l >= 0
	for yyj1366 := 0; ; yyj1366++ {
		if yyhl1366 {
			if yyj1366 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1366Slc = r.DecodeBytes(yys1366Slc, true, true)
		yys1366 := string(yys1366Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1366 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1369 := &x.ObjectMeta
				yyv1369.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = PodSecurityPolicySpec{}
			} else {
				yyv1370 := &x.Spec
				yyv1370.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1366)
		} // end switch yys1366
	} // end for yyj1366
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1371 int
	var yyb1371 bool
	var yyhl1371 bool = l >= 0
	yyj1371++
	if yyhl1371 {
		yyb1371 = yyj1371 > l
	} else {
		yyb1371 = r.CheckBreak()
	}
	if yyb1371 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1371++
	if yyhl1371 {
		yyb1371 = yyj1371 > l
	} else {
		yyb1371 = r.CheckBreak()
	}
	if yyb1371 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1371++
	if yyhl1371 {
		yyb1371 = yyj1371 > l
	} else {
		yyb1371 = r.CheckBreak()
	}
	if yyb1371 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1374 := &x.ObjectMeta
		yyv1374.CodecDecodeSelf(d)
	}
	yyj1371++
	if yyhl1371 {
		yyb1371 = yyj1371 > l
	} else {
		yyb1371 = r.CheckBreak()
	}
	if yyb1371 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = PodSecurityPolicySpec{}
	} else {
		yyv1375 := &x.Spec
		yyv1375.CodecDecodeSelf(d)
	}
	for {
		yyj1371++
		if yyhl1371 {
			yyb1371 = yyj1371 > l
		} else {
			yyb1371 = r.CheckBreak()
		}
		if yyb1371 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1371-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PodSecurityPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1376 := z.EncBinary()
		_ = yym1376
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1377 := !z.EncBinary()
			yy2arr1377 := z.EncBasicHandle().StructToArray
			var yyq1377 [14]bool
			_, _, _ = yysep1377, yyq1377, yy2arr1377
			const yyr1377 bool = false
			yyq1377[0] = x.Privileged != false
			yyq1377[1] = len(x.DefaultAddCapabilities) != 0
			yyq1377[2] = len(x.RequiredDropCapabilities) != 0
			yyq1377[3] = len(x.AllowedCapabilities) != 0
			yyq1377[4] = len(x.Volumes) != 0
			yyq1377[5] = x.HostNetwork != false
			yyq1377[6] = len(x.HostPorts) != 0
			yyq1377[7] = x.HostPID != false
			yyq1377[8] = x.HostIPC != false
			yyq1377[13] = x.ReadOnlyRootFilesystem != false
			var yynn1377 int
			if yyr1377 || yy2arr1377 {
				r.EncodeArrayStart(14)
			} else {
				yynn1377 = 4
				for _, b := range yyq1377 {
					if b {
						yynn1377++
					}
				}
				r.EncodeMapStart(yynn1377)
				yynn1377 = 0
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[0] {
					yym1379 := z.EncBinary()
					_ = yym1379
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1377[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("privileged"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1380 := z.EncBinary()
					_ = yym1380
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[1] {
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1382 := z.EncBinary()
						_ = yym1382
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1377[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1383 := z.EncBinary()
						_ = yym1383
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[2] {
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1385 := z.EncBinary()
						_ = yym1385
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1377[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1386 := z.EncBinary()
						_ = yym1386
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[3] {
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1388 := z.EncBinary()
						_ = yym1388
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1377[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1389 := z.EncBinary()
						_ = yym1389
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
						}
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[4] {
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1391 := z.EncBinary()
						_ = yym1391
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1377[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("volumes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1392 := z.EncBinary()
						_ = yym1392
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[5] {
					yym1394 := z.EncBinary()
					_ = yym1394
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1377[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1395 := z.EncBinary()
					_ = yym1395
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[6] {
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1397 := z.EncBinary()
						_ = yym1397
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1377[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1398 := z.EncBinary()
						_ = yym1398
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[7] {
					yym1400 := z.EncBinary()
					_ = yym1400
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1377[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1401 := z.EncBinary()
					_ = yym1401
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[8] {
					yym1403 := z.EncBinary()
					_ = yym1403
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1377[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1404 := z.EncBinary()
					_ = yym1404
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1406 := &x.SELinux
				yy1406.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1407 := &x.SELinux
				yy1407.CodecEncodeSelf(e)
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1409 := &x.RunAsUser
				yy1409.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1410 := &x.RunAsUser
				yy1410.CodecEncodeSelf(e)
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1412 := &x.SupplementalGroups
				yy1412.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1413 := &x.SupplementalGroups
				yy1413.CodecEncodeSelf(e)
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1415 := &x.FSGroup
				yy1415.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1416 := &x.FSGroup
				yy1416.CodecEncodeSelf(e)
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1377[13] {
					yym1418 := z.EncBinary()
					_ = yym1418
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1377[13] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1419 := z.EncBinary()
					_ = yym1419
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				}
			}
			if yyr1377 || yy2arr1377 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1420 := z.DecBinary()
	_ = yym1420
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1421 := r.ContainerType()
		if yyct1421 == codecSelferValueTypeMap1234 {
			yyl1421 := r.ReadMapStart()
			if yyl1421 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1421, d)
			}
		} else if yyct1421 == codecSelferValueTypeArray1234 {
			yyl1421 := r.ReadArrayStart()
			if yyl1421 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1421, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1422Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1422Slc
	var yyhl1422 bool = l >= 0
	for yyj1422 := 0; ; yyj1422++ {
		if yyhl1422 {
			if yyj1422 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1422Slc = r.DecodeBytes(yys1422Slc, true, true)
		yys1422 := string(yys1422Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1422 {
		case "privileged":
			if r.TryDecodeAsNil() {
				x.Privileged = false
			} else {
				x.Privileged = bool(r.DecodeBool())
			}
		case "defaultAddCapabilities":
			if r.TryDecodeAsNil() {
				x.DefaultAddCapabilities = nil
			} else {
				yyv1424 := &x.DefaultAddCapabilities
				yym1425 := z.DecBinary()
				_ = yym1425
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1424), d)
				}
			}
		case "requiredDropCapabilities":
			if r.TryDecodeAsNil() {
				x.RequiredDropCapabilities = nil
			} else {
				yyv1426 := &x.RequiredDropCapabilities
				yym1427 := z.DecBinary()
				_ = yym1427
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1426), d)
				}
			}
		case "allowedCapabilities":
			if r.TryDecodeAsNil() {
				x.AllowedCapabilities = nil
			} else {
				yyv1428 := &x.AllowedCapabilities
				yym1429 := z.DecBinary()
				_ = yym1429
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1428), d)
				}
			}
		case "volumes":
			if r.TryDecodeAsNil() {
				x.Volumes = nil
			} else {
				yyv1430 := &x.Volumes
				yym1431 := z.DecBinary()
				_ = yym1431
				if false {
				} else {
					h.decSliceFSType((*[]FSType)(yyv1430), d)
				}
			}
		case "hostNetwork":
			if r.TryDecodeAsNil() {
				x.HostNetwork = false
			} else {
				x.HostNetwork = bool(r.DecodeBool())
			}
		case "hostPorts":
			if r.TryDecodeAsNil() {
				x.HostPorts = nil
			} else {
				yyv1433 := &x.HostPorts
				yym1434 := z.DecBinary()
				_ = yym1434
				if false {
				} else {
					h.decSliceHostPortRange((*[]HostPortRange)(yyv1433), d)
				}
			}
		case "hostPID":
			if r.TryDecodeAsNil() {
				x.HostPID = false
			} else {
				x.HostPID = bool(r.DecodeBool())
			}
		case "hostIPC":
			if r.TryDecodeAsNil() {
				x.HostIPC = false
			} else {
				x.HostIPC = bool(r.DecodeBool())
			}
		case "seLinux":
			if r.TryDecodeAsNil() {
				x.SELinux = SELinuxStrategyOptions{}
			} else {
				yyv1437 := &x.SELinux
				yyv1437.CodecDecodeSelf(d)
			}
		case "runAsUser":
			if r.TryDecodeAsNil() {
				x.RunAsUser = RunAsUserStrategyOptions{}
			} else {
				yyv1438 := &x.RunAsUser
				yyv1438.CodecDecodeSelf(d)
			}
		case "supplementalGroups":
			if r.TryDecodeAsNil() {
				x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
			} else {
				yyv1439 := &x.SupplementalGroups
				yyv1439.CodecDecodeSelf(d)
			}
		case "fsGroup":
			if r.TryDecodeAsNil() {
				x.FSGroup = FSGroupStrategyOptions{}
			} else {
				yyv1440 := &x.FSGroup
				yyv1440.CodecDecodeSelf(d)
			}
		case "readOnlyRootFilesystem":
			if r.TryDecodeAsNil() {
				x.ReadOnlyRootFilesystem = false
			} else {
				x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1422)
		} // end switch yys1422
	} // end for yyj1422
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1442 int
	var yyb1442 bool
	var yyhl1442 bool = l >= 0
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Privileged = false
	} else {
		x.Privileged = bool(r.DecodeBool())
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DefaultAddCapabilities = nil
	} else {
		yyv1444 := &x.DefaultAddCapabilities
		yym1445 := z.DecBinary()
		_ = yym1445
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1444), d)
		}
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RequiredDropCapabilities = nil
	} else {
		yyv1446 := &x.RequiredDropCapabilities
		yym1447 := z.DecBinary()
		_ = yym1447
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1446), d)
		}
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AllowedCapabilities = nil
	} else {
		yyv1448 := &x.AllowedCapabilities
		yym1449 := z.DecBinary()
		_ = yym1449
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1448), d)
		}
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Volumes = nil
	} else {
		yyv1450 := &x.Volumes
		yym1451 := z.DecBinary()
		_ = yym1451
		if false {
		} else {
			h.decSliceFSType((*[]FSType)(yyv1450), d)
		}
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostNetwork = false
	} else {
		x.HostNetwork = bool(r.DecodeBool())
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPorts = nil
	} else {
		yyv1453 := &x.HostPorts
		yym1454 := z.DecBinary()
		_ = yym1454
		if false {
		} else {
			h.decSliceHostPortRange((*[]HostPortRange)(yyv1453), d)
		}
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPID = false
	} else {
		x.HostPID = bool(r.DecodeBool())
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostIPC = false
	} else {
		x.HostIPC = bool(r.DecodeBool())
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SELinux = SELinuxStrategyOptions{}
	} else {
		yyv1457 := &x.SELinux
		yyv1457.CodecDecodeSelf(d)
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RunAsUser = RunAsUserStrategyOptions{}
	} else {
		yyv1458 := &x.RunAsUser
		yyv1458.CodecDecodeSelf(d)
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
	} else {
		yyv1459 := &x.SupplementalGroups
		yyv1459.CodecDecodeSelf(d)
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FSGroup = FSGroupStrategyOptions{}
	} else {
		yyv1460 := &x.FSGroup
		yyv1460.CodecDecodeSelf(d)
	}
	yyj1442++
	if yyhl1442 {
		yyb1442 = yyj1442 > l
	} else {
		yyb1442 = r.CheckBreak()
	}
	if yyb1442 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadOnlyRootFilesystem = false
	} else {
		x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
	}
	for {
		yyj1442++
		if yyhl1442 {
			yyb1442 = yyj1442 > l
		} else {
			yyb1442 = r.CheckBreak()
		}
		if yyb1442 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1442-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1462 := z.EncBinary()
	_ = yym1462
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *FSType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1463 := z.DecBinary()
	_ = yym1463
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1464 := z.EncBinary()
		_ = yym1464
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1465 := !z.EncBinary()
			yy2arr1465 := z.EncBasicHandle().StructToArray
			var yyq1465 [2]bool
			_, _, _ = yysep1465, yyq1465, yy2arr1465
			const yyr1465 bool = false
			var yynn1465 int
			if yyr1465 || yy2arr1465 {
				r.EncodeArrayStart(2)
			} else {
				yynn1465 = 2
				for _, b := range yyq1465 {
					if b {
						yynn1465++
					}
				}
				r.EncodeMapStart(yynn1465)
				yynn1465 = 0
			}
			if yyr1465 || yy2arr1465 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1467 := z.EncBinary()
				_ = yym1467
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1468 := z.EncBinary()
				_ = yym1468
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1465 || yy2arr1465 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1470 := z.EncBinary()
				_ = yym1470
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1471 := z.EncBinary()
				_ = yym1471
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1465 || yy2arr1465 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *HostPortRange) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1472 := z.DecBinary()
	_ = yym1472
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1473 := r.ContainerType()
		if yyct1473 == codecSelferValueTypeMap1234 {
			yyl1473 := r.ReadMapStart()
			if yyl1473 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1473, d)
			}
		} else if yyct1473 == codecSelferValueTypeArray1234 {
			yyl1473 := r.ReadArrayStart()
			if yyl1473 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1473, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *HostPortRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1474Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1474Slc
	var yyhl1474 bool = l >= 0
	for yyj1474 := 0; ; yyj1474++ {
		if yyhl1474 {
			if yyj1474 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1474Slc = r.DecodeBytes(yys1474Slc, true, true)
		yys1474 := string(yys1474Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1474 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int32(r.DecodeInt(32))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1474)
		} // end switch yys1474
	} // end for yyj1474
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *HostPortRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1477 int
	var yyb1477 bool
	var yyhl1477 bool = l >= 0
	yyj1477++
	if yyhl1477 {
		yyb1477 = yyj1477 > l
	} else {
		yyb1477 = r.CheckBreak()
	}
	if yyb1477 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int32(r.DecodeInt(32))
	}
	yyj1477++
	if yyhl1477 {
		yyb1477 = yyj1477 > l
	} else {
		yyb1477 = r.CheckBreak()
	}
	if yyb1477 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int32(r.DecodeInt(32))
	}
	for {
		yyj1477++
		if yyhl1477 {
			yyb1477 = yyj1477 > l
		} else {
			yyb1477 = r.CheckBreak()
		}
		if yyb1477 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1477-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1480 := z.EncBinary()
		_ = yym1480
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1481 := !z.EncBinary()
			yy2arr1481 := z.EncBasicHandle().StructToArray
			var yyq1481 [2]bool
			_, _, _ = yysep1481, yyq1481, yy2arr1481
			const yyr1481 bool = false
			yyq1481[1] = x.SELinuxOptions != nil
			var yynn1481 int
			if yyr1481 || yy2arr1481 {
				r.EncodeArrayStart(2)
			} else {
				yynn1481 = 1
				for _, b := range yyq1481 {
					if b {
						yynn1481++
					}
				}
				r.EncodeMapStart(yynn1481)
				yynn1481 = 0
			}
			if yyr1481 || yy2arr1481 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Rule.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rule"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Rule.CodecEncodeSelf(e)
			}
			if yyr1481 || yy2arr1481 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1481[1] {
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1481[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1481 || yy2arr1481 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SELinuxStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1484 := z.DecBinary()
	_ = yym1484
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1485 := r.ContainerType()
		if yyct1485 == codecSelferValueTypeMap1234 {
			yyl1485 := r.ReadMapStart()
			if yyl1485 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1485, d)
			}
		} else if yyct1485 == codecSelferValueTypeArray1234 {
			yyl1485 := r.ReadArrayStart()
			if yyl1485 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1485, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SELinuxStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1486Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1486Slc
	var yyhl1486 bool = l >= 0
	for yyj1486 := 0; ; yyj1486++ {
		if yyhl1486 {
			if yyj1486 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1486Slc = r.DecodeBytes(yys1486Slc, true, true)
		yys1486 := string(yys1486Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1486 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SELinuxStrategy(r.DecodeString())
			}
		case "seLinuxOptions":
			if r.TryDecodeAsNil() {
				if x.SELinuxOptions != nil {
					x.SELinuxOptions = nil
				}
			} else {
				if x.SELinuxOptions == nil {
					x.SELinuxOptions = new(pkg2_v1.SELinuxOptions)
				}
				x.SELinuxOptions.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1486)
		} // end switch yys1486
	} // end for yyj1486
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SELinuxStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1489 int
	var yyb1489 bool
	var yyhl1489 bool = l >= 0
	yyj1489++
	if yyhl1489 {
		yyb1489 = yyj1489 > l
	} else {
		yyb1489 = r.CheckBreak()
	}
	if yyb1489 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SELinuxStrategy(r.DecodeString())
	}
	yyj1489++
	if yyhl1489 {
		yyb1489 = yyj1489 > l
	} else {
		yyb1489 = r.CheckBreak()
	}
	if yyb1489 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.SELinuxOptions != nil {
			x.SELinuxOptions = nil
		}
	} else {
		if x.SELinuxOptions == nil {
			x.SELinuxOptions = new(pkg2_v1.SELinuxOptions)
		}
		x.SELinuxOptions.CodecDecodeSelf(d)
	}
	for {
		yyj1489++
		if yyhl1489 {
			yyb1489 = yyj1489 > l
		} else {
			yyb1489 = r.CheckBreak()
		}
		if yyb1489 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1489-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1492 := z.EncBinary()
	_ = yym1492
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *SELinuxStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1493 := z.DecBinary()
	_ = yym1493
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *RunAsUserStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1494 := z.EncBinary()
		_ = yym1494
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1495 := !z.EncBinary()
			yy2arr1495 := z.EncBasicHandle().StructToArray
			var yyq1495 [2]bool
			_, _, _ = yysep1495, yyq1495, yy2arr1495
			const yyr1495 bool = false
			yyq1495[1] = len(x.Ranges) != 0
			var yynn1495 int
			if yyr1495 || yy2arr1495 {
				r.EncodeArrayStart(2)
			} else {
				yynn1495 = 1
				for _, b := range yyq1495 {
					if b {
						yynn1495++
					}
				}
				r.EncodeMapStart(yynn1495)
				yynn1495 = 0
			}
			if yyr1495 || yy2arr1495 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Rule.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rule"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Rule.CodecEncodeSelf(e)
			}
			if yyr1495 || yy2arr1495 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1495[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1498 := z.EncBinary()
						_ = yym1498
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1495[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1499 := z.EncBinary()
						_ = yym1499
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1495 || yy2arr1495 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *RunAsUserStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1500 := z.DecBinary()
	_ = yym1500
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1501 := r.ContainerType()
		if yyct1501 == codecSelferValueTypeMap1234 {
			yyl1501 := r.ReadMapStart()
			if yyl1501 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1501, d)
			}
		} else if yyct1501 == codecSelferValueTypeArray1234 {
			yyl1501 := r.ReadArrayStart()
			if yyl1501 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1501, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1502Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1502Slc
	var yyhl1502 bool = l >= 0
	for yyj1502 := 0; ; yyj1502++ {
		if yyhl1502 {
			if yyj1502 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1502Slc = r.DecodeBytes(yys1502Slc, true, true)
		yys1502 := string(yys1502Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1502 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = RunAsUserStrategy(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1504 := &x.Ranges
				yym1505 := z.DecBinary()
				_ = yym1505
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1504), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1502)
		} // end switch yys1502
	} // end for yyj1502
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *RunAsUserStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1506 int
	var yyb1506 bool
	var yyhl1506 bool = l >= 0
	yyj1506++
	if yyhl1506 {
		yyb1506 = yyj1506 > l
	} else {
		yyb1506 = r.CheckBreak()
	}
	if yyb1506 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = RunAsUserStrategy(r.DecodeString())
	}
	yyj1506++
	if yyhl1506 {
		yyb1506 = yyj1506 > l
	} else {
		yyb1506 = r.CheckBreak()
	}
	if yyb1506 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1508 := &x.Ranges
		yym1509 := z.DecBinary()
		_ = yym1509
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1508), d)
		}
	}
	for {
		yyj1506++
		if yyhl1506 {
			yyb1506 = yyj1506 > l
		} else {
			yyb1506 = r.CheckBreak()
		}
		if yyb1506 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1506-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *IDRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1510 := z.EncBinary()
		_ = yym1510
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1511 := !z.EncBinary()
			yy2arr1511 := z.EncBasicHandle().StructToArray
			var yyq1511 [2]bool
			_, _, _ = yysep1511, yyq1511, yy2arr1511
			const yyr1511 bool = false
			var yynn1511 int
			if yyr1511 || yy2arr1511 {
				r.EncodeArrayStart(2)
			} else {
				yynn1511 = 2
				for _, b := range yyq1511 {
					if b {
						yynn1511++
					}
				}
				r.EncodeMapStart(yynn1511)
				yynn1511 = 0
			}
			if yyr1511 || yy2arr1511 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1513 := z.EncBinary()
				_ = yym1513
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1514 := z.EncBinary()
				_ = yym1514
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1511 || yy2arr1511 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1516 := z.EncBinary()
				_ = yym1516
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1517 := z.EncBinary()
				_ = yym1517
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1511 || yy2arr1511 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *IDRange) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1518 := z.DecBinary()
	_ = yym1518
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1519 := r.ContainerType()
		if yyct1519 == codecSelferValueTypeMap1234 {
			yyl1519 := r.ReadMapStart()
			if yyl1519 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1519, d)
			}
		} else if yyct1519 == codecSelferValueTypeArray1234 {
			yyl1519 := r.ReadArrayStart()
			if yyl1519 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1519, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1520Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1520Slc
	var yyhl1520 bool = l >= 0
	for yyj1520 := 0; ; yyj1520++ {
		if yyhl1520 {
			if yyj1520 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1520Slc = r.DecodeBytes(yys1520Slc, true, true)
		yys1520 := string(yys1520Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1520 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int64(r.DecodeInt(64))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1520)
		} // end switch yys1520
	} // end for yyj1520
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *IDRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1523 int
	var yyb1523 bool
	var yyhl1523 bool = l >= 0
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int64(r.DecodeInt(64))
	}
	yyj1523++
	if yyhl1523 {
		yyb1523 = yyj1523 > l
	} else {
		yyb1523 = r.CheckBreak()
	}
	if yyb1523 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int64(r.DecodeInt(64))
	}
	for {
		yyj1523++
		if yyhl1523 {
			yyb1523 = yyj1523 > l
		} else {
			yyb1523 = r.CheckBreak()
		}
		if yyb1523 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1523-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1526 := z.EncBinary()
	_ = yym1526
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *RunAsUserStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1527 := z.DecBinary()
	_ = yym1527
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *FSGroupStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1528 := z.EncBinary()
		_ = yym1528
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1529 := !z.EncBinary()
			yy2arr1529 := z.EncBasicHandle().StructToArray
			var yyq1529 [2]bool
			_, _, _ = yysep1529, yyq1529, yy2arr1529
			const yyr1529 bool = false
			yyq1529[0] = x.Rule != ""
			yyq1529[1] = len(x.Ranges) != 0
			var yynn1529 int
			if yyr1529 || yy2arr1529 {
				r.EncodeArrayStart(2)
			} else {
				yynn1529 = 0
				for _, b := range yyq1529 {
					if b {
						yynn1529++
					}
				}
				r.EncodeMapStart(yynn1529)
				yynn1529 = 0
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1529[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1529[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1532 := z.EncBinary()
						_ = yym1532
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1529[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1533 := z.EncBinary()
						_ = yym1533
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1529 || yy2arr1529 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *FSGroupStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1534 := z.DecBinary()
	_ = yym1534
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1535 := r.ContainerType()
		if yyct1535 == codecSelferValueTypeMap1234 {
			yyl1535 := r.ReadMapStart()
			if yyl1535 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1535, d)
			}
		} else if yyct1535 == codecSelferValueTypeArray1234 {
			yyl1535 := r.ReadArrayStart()
			if yyl1535 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1535, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *FSGroupStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1536Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1536Slc
	var yyhl1536 bool = l >= 0
	for yyj1536 := 0; ; yyj1536++ {
		if yyhl1536 {
			if yyj1536 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1536Slc = r.DecodeBytes(yys1536Slc, true, true)
		yys1536 := string(yys1536Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1536 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = FSGroupStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1538 := &x.Ranges
				yym1539 := z.DecBinary()
				_ = yym1539
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1538), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1536)
		} // end switch yys1536
	} // end for yyj1536
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *FSGroupStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1540 int
	var yyb1540 bool
	var yyhl1540 bool = l >= 0
	yyj1540++
	if yyhl1540 {
		yyb1540 = yyj1540 > l
	} else {
		yyb1540 = r.CheckBreak()
	}
	if yyb1540 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = FSGroupStrategyType(r.DecodeString())
	}
	yyj1540++
	if yyhl1540 {
		yyb1540 = yyj1540 > l
	} else {
		yyb1540 = r.CheckBreak()
	}
	if yyb1540 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1542 := &x.Ranges
		yym1543 := z.DecBinary()
		_ = yym1543
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1542), d)
		}
	}
	for {
		yyj1540++
		if yyhl1540 {
			yyb1540 = yyj1540 > l
		} else {
			yyb1540 = r.CheckBreak()
		}
		if yyb1540 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1540-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1544 := z.EncBinary()
	_ = yym1544
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *FSGroupStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1545 := z.DecBinary()
	_ = yym1545
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *SupplementalGroupsStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1546 := z.EncBinary()
		_ = yym1546
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1547 := !z.EncBinary()
			yy2arr1547 := z.EncBasicHandle().StructToArray
			var yyq1547 [2]bool
			_, _, _ = yysep1547, yyq1547, yy2arr1547
			const yyr1547 bool = false
			yyq1547[0] = x.Rule != ""
			yyq1547[1] = len(x.Ranges) != 0
			var yynn1547 int
			if yyr1547 || yy2arr1547 {
				r.EncodeArrayStart(2)
			} else {
				yynn1547 = 0
				for _, b := range yyq1547 {
					if b {
						yynn1547++
					}
				}
				r.EncodeMapStart(yynn1547)
				yynn1547 = 0
			}
			if yyr1547 || yy2arr1547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1547[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1547[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1547 || yy2arr1547 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1547[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1550 := z.EncBinary()
						_ = yym1550
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1547[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1551 := z.EncBinary()
						_ = yym1551
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1547 || yy2arr1547 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SupplementalGroupsStrategyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1552 := z.DecBinary()
	_ = yym1552
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1553 := r.ContainerType()
		if yyct1553 == codecSelferValueTypeMap1234 {
			yyl1553 := r.ReadMapStart()
			if yyl1553 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1553, d)
			}
		} else if yyct1553 == codecSelferValueTypeArray1234 {
			yyl1553 := r.ReadArrayStart()
			if yyl1553 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1553, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1554Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1554Slc
	var yyhl1554 bool = l >= 0
	for yyj1554 := 0; ; yyj1554++ {
		if yyhl1554 {
			if yyj1554 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1554Slc = r.DecodeBytes(yys1554Slc, true, true)
		yys1554 := string(yys1554Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1554 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1556 := &x.Ranges
				yym1557 := z.DecBinary()
				_ = yym1557
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1556), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1554)
		} // end switch yys1554
	} // end for yyj1554
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SupplementalGroupsStrategyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1558 int
	var yyb1558 bool
	var yyhl1558 bool = l >= 0
	yyj1558++
	if yyhl1558 {
		yyb1558 = yyj1558 > l
	} else {
		yyb1558 = r.CheckBreak()
	}
	if yyb1558 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
	}
	yyj1558++
	if yyhl1558 {
		yyb1558 = yyj1558 > l
	} else {
		yyb1558 = r.CheckBreak()
	}
	if yyb1558 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1560 := &x.Ranges
		yym1561 := z.DecBinary()
		_ = yym1561
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1560), d)
		}
	}
	for {
		yyj1558++
		if yyhl1558 {
			yyb1558 = yyj1558 > l
		} else {
			yyb1558 = r.CheckBreak()
		}
		if yyb1558 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1558-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1562 := z.EncBinary()
	_ = yym1562
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF81234, string(x))
	}
}

func (x *SupplementalGroupsStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1563 := z.DecBinary()
	_ = yym1563
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *PodSecurityPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1564 := z.EncBinary()
		_ = yym1564
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1565 := !z.EncBinary()
			yy2arr1565 := z.EncBasicHandle().StructToArray
			var yyq1565 [4]bool
			_, _, _ = yysep1565, yyq1565, yy2arr1565
			const yyr1565 bool = false
			yyq1565[0] = x.Kind != ""
			yyq1565[1] = x.APIVersion != ""
			yyq1565[2] = true
			var yynn1565 int
			if yyr1565 || yy2arr1565 {
				r.EncodeArrayStart(4)
			} else {
				yynn1565 = 1
				for _, b := range yyq1565 {
					if b {
						yynn1565++
					}
				}
				r.EncodeMapStart(yynn1565)
				yynn1565 = 0
			}
			if yyr1565 || yy2arr1565 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1565[0] {
					yym1567 := z.EncBinary()
					_ = yym1567
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1565[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1568 := z.EncBinary()
					_ = yym1568
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1565 || yy2arr1565 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1565[1] {
					yym1570 := z.EncBinary()
					_ = yym1570
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1565[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1571 := z.EncBinary()
					_ = yym1571
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1565 || yy2arr1565 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1565[2] {
					yy1573 := &x.ListMeta
					yym1574 := z.EncBinary()
					_ = yym1574
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1573) {
					} else {
						z.EncFallback(yy1573)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1565[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1575 := &x.ListMeta
					yym1576 := z.EncBinary()
					_ = yym1576
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1575) {
					} else {
						z.EncFallback(yy1575)
					}
				}
			}
			if yyr1565 || yy2arr1565 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1578 := z.EncBinary()
					_ = yym1578
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1579 := z.EncBinary()
					_ = yym1579
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			}
			if yyr1565 || yy2arr1565 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *PodSecurityPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1580 := z.DecBinary()
	_ = yym1580
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1581 := r.ContainerType()
		if yyct1581 == codecSelferValueTypeMap1234 {
			yyl1581 := r.ReadMapStart()
			if yyl1581 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1581, d)
			}
		} else if yyct1581 == codecSelferValueTypeArray1234 {
			yyl1581 := r.ReadArrayStart()
			if yyl1581 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1581, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1582Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1582Slc
	var yyhl1582 bool = l >= 0
	for yyj1582 := 0; ; yyj1582++ {
		if yyhl1582 {
			if yyj1582 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1582Slc = r.DecodeBytes(yys1582Slc, true, true)
		yys1582 := string(yys1582Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1582 {
		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 {
				yyv1585 := &x.ListMeta
				yym1586 := z.DecBinary()
				_ = yym1586
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1585) {
				} else {
					z.DecFallback(yyv1585, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1587 := &x.Items
				yym1588 := z.DecBinary()
				_ = yym1588
				if false {
				} else {
					h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1587), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1582)
		} // end switch yys1582
	} // end for yyj1582
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1589 int
	var yyb1589 bool
	var yyhl1589 bool = l >= 0
	yyj1589++
	if yyhl1589 {
		yyb1589 = yyj1589 > l
	} else {
		yyb1589 = r.CheckBreak()
	}
	if yyb1589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1589++
	if yyhl1589 {
		yyb1589 = yyj1589 > l
	} else {
		yyb1589 = r.CheckBreak()
	}
	if yyb1589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1589++
	if yyhl1589 {
		yyb1589 = yyj1589 > l
	} else {
		yyb1589 = r.CheckBreak()
	}
	if yyb1589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1592 := &x.ListMeta
		yym1593 := z.DecBinary()
		_ = yym1593
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1592) {
		} else {
			z.DecFallback(yyv1592, false)
		}
	}
	yyj1589++
	if yyhl1589 {
		yyb1589 = yyj1589 > l
	} else {
		yyb1589 = r.CheckBreak()
	}
	if yyb1589 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1594 := &x.Items
		yym1595 := z.DecBinary()
		_ = yym1595
		if false {
		} else {
			h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1594), d)
		}
	}
	for {
		yyj1589++
		if yyhl1589 {
			yyb1589 = yyj1589 > l
		} else {
			yyb1589 = r.CheckBreak()
		}
		if yyb1589 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1589-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1596 := z.EncBinary()
		_ = yym1596
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1597 := !z.EncBinary()
			yy2arr1597 := z.EncBasicHandle().StructToArray
			var yyq1597 [4]bool
			_, _, _ = yysep1597, yyq1597, yy2arr1597
			const yyr1597 bool = false
			yyq1597[0] = x.Kind != ""
			yyq1597[1] = x.APIVersion != ""
			yyq1597[2] = true
			yyq1597[3] = true
			var yynn1597 int
			if yyr1597 || yy2arr1597 {
				r.EncodeArrayStart(4)
			} else {
				yynn1597 = 0
				for _, b := range yyq1597 {
					if b {
						yynn1597++
					}
				}
				r.EncodeMapStart(yynn1597)
				yynn1597 = 0
			}
			if yyr1597 || yy2arr1597 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1597[0] {
					yym1599 := z.EncBinary()
					_ = yym1599
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1597[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1600 := z.EncBinary()
					_ = yym1600
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1597 || yy2arr1597 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1597[1] {
					yym1602 := z.EncBinary()
					_ = yym1602
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1597[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1603 := z.EncBinary()
					_ = yym1603
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1597 || yy2arr1597 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1597[2] {
					yy1605 := &x.ObjectMeta
					yy1605.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1597[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1606 := &x.ObjectMeta
					yy1606.CodecEncodeSelf(e)
				}
			}
			if yyr1597 || yy2arr1597 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1597[3] {
					yy1608 := &x.Spec
					yy1608.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1597[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1609 := &x.Spec
					yy1609.CodecEncodeSelf(e)
				}
			}
			if yyr1597 || yy2arr1597 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1610 := z.DecBinary()
	_ = yym1610
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1611 := r.ContainerType()
		if yyct1611 == codecSelferValueTypeMap1234 {
			yyl1611 := r.ReadMapStart()
			if yyl1611 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1611, d)
			}
		} else if yyct1611 == codecSelferValueTypeArray1234 {
			yyl1611 := r.ReadArrayStart()
			if yyl1611 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1611, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1612Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1612Slc
	var yyhl1612 bool = l >= 0
	for yyj1612 := 0; ; yyj1612++ {
		if yyhl1612 {
			if yyj1612 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1612Slc = r.DecodeBytes(yys1612Slc, true, true)
		yys1612 := string(yys1612Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1612 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_v1.ObjectMeta{}
			} else {
				yyv1615 := &x.ObjectMeta
				yyv1615.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = NetworkPolicySpec{}
			} else {
				yyv1616 := &x.Spec
				yyv1616.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1612)
		} // end switch yys1612
	} // end for yyj1612
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1617 int
	var yyb1617 bool
	var yyhl1617 bool = l >= 0
	yyj1617++
	if yyhl1617 {
		yyb1617 = yyj1617 > l
	} else {
		yyb1617 = r.CheckBreak()
	}
	if yyb1617 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1617++
	if yyhl1617 {
		yyb1617 = yyj1617 > l
	} else {
		yyb1617 = r.CheckBreak()
	}
	if yyb1617 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1617++
	if yyhl1617 {
		yyb1617 = yyj1617 > l
	} else {
		yyb1617 = r.CheckBreak()
	}
	if yyb1617 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1620 := &x.ObjectMeta
		yyv1620.CodecDecodeSelf(d)
	}
	yyj1617++
	if yyhl1617 {
		yyb1617 = yyj1617 > l
	} else {
		yyb1617 = r.CheckBreak()
	}
	if yyb1617 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = NetworkPolicySpec{}
	} else {
		yyv1621 := &x.Spec
		yyv1621.CodecDecodeSelf(d)
	}
	for {
		yyj1617++
		if yyhl1617 {
			yyb1617 = yyj1617 > l
		} else {
			yyb1617 = r.CheckBreak()
		}
		if yyb1617 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1617-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicySpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1622 := z.EncBinary()
		_ = yym1622
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1623 := !z.EncBinary()
			yy2arr1623 := z.EncBasicHandle().StructToArray
			var yyq1623 [2]bool
			_, _, _ = yysep1623, yyq1623, yy2arr1623
			const yyr1623 bool = false
			yyq1623[1] = len(x.Ingress) != 0
			var yynn1623 int
			if yyr1623 || yy2arr1623 {
				r.EncodeArrayStart(2)
			} else {
				yynn1623 = 1
				for _, b := range yyq1623 {
					if b {
						yynn1623++
					}
				}
				r.EncodeMapStart(yynn1623)
				yynn1623 = 0
			}
			if yyr1623 || yy2arr1623 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1625 := &x.PodSelector
				yy1625.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1626 := &x.PodSelector
				yy1626.CodecEncodeSelf(e)
			}
			if yyr1623 || yy2arr1623 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1623[1] {
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1628 := z.EncBinary()
						_ = yym1628
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1623[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ingress"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1629 := z.EncBinary()
						_ = yym1629
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				}
			}
			if yyr1623 || yy2arr1623 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicySpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1630 := z.DecBinary()
	_ = yym1630
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1631 := r.ContainerType()
		if yyct1631 == codecSelferValueTypeMap1234 {
			yyl1631 := r.ReadMapStart()
			if yyl1631 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1631, d)
			}
		} else if yyct1631 == codecSelferValueTypeArray1234 {
			yyl1631 := r.ReadArrayStart()
			if yyl1631 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1631, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1632Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1632Slc
	var yyhl1632 bool = l >= 0
	for yyj1632 := 0; ; yyj1632++ {
		if yyhl1632 {
			if yyj1632 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1632Slc = r.DecodeBytes(yys1632Slc, true, true)
		yys1632 := string(yys1632Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1632 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				x.PodSelector = LabelSelector{}
			} else {
				yyv1633 := &x.PodSelector
				yyv1633.CodecDecodeSelf(d)
			}
		case "ingress":
			if r.TryDecodeAsNil() {
				x.Ingress = nil
			} else {
				yyv1634 := &x.Ingress
				yym1635 := z.DecBinary()
				_ = yym1635
				if false {
				} else {
					h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1634), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1632)
		} // end switch yys1632
	} // end for yyj1632
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicySpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1636 int
	var yyb1636 bool
	var yyhl1636 bool = l >= 0
	yyj1636++
	if yyhl1636 {
		yyb1636 = yyj1636 > l
	} else {
		yyb1636 = r.CheckBreak()
	}
	if yyb1636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PodSelector = LabelSelector{}
	} else {
		yyv1637 := &x.PodSelector
		yyv1637.CodecDecodeSelf(d)
	}
	yyj1636++
	if yyhl1636 {
		yyb1636 = yyj1636 > l
	} else {
		yyb1636 = r.CheckBreak()
	}
	if yyb1636 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ingress = nil
	} else {
		yyv1638 := &x.Ingress
		yym1639 := z.DecBinary()
		_ = yym1639
		if false {
		} else {
			h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1638), d)
		}
	}
	for {
		yyj1636++
		if yyhl1636 {
			yyb1636 = yyj1636 > l
		} else {
			yyb1636 = r.CheckBreak()
		}
		if yyb1636 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1636-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyIngressRule) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1640 := z.EncBinary()
		_ = yym1640
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1641 := !z.EncBinary()
			yy2arr1641 := z.EncBasicHandle().StructToArray
			var yyq1641 [2]bool
			_, _, _ = yysep1641, yyq1641, yy2arr1641
			const yyr1641 bool = false
			yyq1641[0] = len(x.Ports) != 0
			yyq1641[1] = len(x.From) != 0
			var yynn1641 int
			if yyr1641 || yy2arr1641 {
				r.EncodeArrayStart(2)
			} else {
				yynn1641 = 0
				for _, b := range yyq1641 {
					if b {
						yynn1641++
					}
				}
				r.EncodeMapStart(yynn1641)
				yynn1641 = 0
			}
			if yyr1641 || yy2arr1641 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1641[0] {
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1643 := z.EncBinary()
						_ = yym1643
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1641[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ports"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1644 := z.EncBinary()
						_ = yym1644
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				}
			}
			if yyr1641 || yy2arr1641 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1641[1] {
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1646 := z.EncBinary()
						_ = yym1646
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1641[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("from"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1647 := z.EncBinary()
						_ = yym1647
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				}
			}
			if yyr1641 || yy2arr1641 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyIngressRule) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1648 := z.DecBinary()
	_ = yym1648
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1649 := r.ContainerType()
		if yyct1649 == codecSelferValueTypeMap1234 {
			yyl1649 := r.ReadMapStart()
			if yyl1649 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1649, d)
			}
		} else if yyct1649 == codecSelferValueTypeArray1234 {
			yyl1649 := r.ReadArrayStart()
			if yyl1649 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1649, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyIngressRule) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1650Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1650Slc
	var yyhl1650 bool = l >= 0
	for yyj1650 := 0; ; yyj1650++ {
		if yyhl1650 {
			if yyj1650 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1650Slc = r.DecodeBytes(yys1650Slc, true, true)
		yys1650 := string(yys1650Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1650 {
		case "ports":
			if r.TryDecodeAsNil() {
				x.Ports = nil
			} else {
				yyv1651 := &x.Ports
				yym1652 := z.DecBinary()
				_ = yym1652
				if false {
				} else {
					h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1651), d)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv1653 := &x.From
				yym1654 := z.DecBinary()
				_ = yym1654
				if false {
				} else {
					h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1653), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1650)
		} // end switch yys1650
	} // end for yyj1650
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyIngressRule) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1655 int
	var yyb1655 bool
	var yyhl1655 bool = l >= 0
	yyj1655++
	if yyhl1655 {
		yyb1655 = yyj1655 > l
	} else {
		yyb1655 = r.CheckBreak()
	}
	if yyb1655 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ports = nil
	} else {
		yyv1656 := &x.Ports
		yym1657 := z.DecBinary()
		_ = yym1657
		if false {
		} else {
			h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1656), d)
		}
	}
	yyj1655++
	if yyhl1655 {
		yyb1655 = yyj1655 > l
	} else {
		yyb1655 = r.CheckBreak()
	}
	if yyb1655 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv1658 := &x.From
		yym1659 := z.DecBinary()
		_ = yym1659
		if false {
		} else {
			h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1658), d)
		}
	}
	for {
		yyj1655++
		if yyhl1655 {
			yyb1655 = yyj1655 > l
		} else {
			yyb1655 = r.CheckBreak()
		}
		if yyb1655 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1655-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyPort) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1660 := z.EncBinary()
		_ = yym1660
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1661 := !z.EncBinary()
			yy2arr1661 := z.EncBasicHandle().StructToArray
			var yyq1661 [2]bool
			_, _, _ = yysep1661, yyq1661, yy2arr1661
			const yyr1661 bool = false
			yyq1661[0] = x.Protocol != nil
			yyq1661[1] = x.Port != nil
			var yynn1661 int
			if yyr1661 || yy2arr1661 {
				r.EncodeArrayStart(2)
			} else {
				yynn1661 = 0
				for _, b := range yyq1661 {
					if b {
						yynn1661++
					}
				}
				r.EncodeMapStart(yynn1661)
				yynn1661 = 0
			}
			if yyr1661 || yy2arr1661 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1661[0] {
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1663 := *x.Protocol
						yym1664 := z.EncBinary()
						_ = yym1664
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1663) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1663))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1661[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("protocol"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1665 := *x.Protocol
						yym1666 := z.EncBinary()
						_ = yym1666
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1665) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1665))
						}
					}
				}
			}
			if yyr1661 || yy2arr1661 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1661[1] {
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1668 := z.EncBinary()
						_ = yym1668
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1668 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1661[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("port"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1669 := z.EncBinary()
						_ = yym1669
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1669 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				}
			}
			if yyr1661 || yy2arr1661 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyPort) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1670 := z.DecBinary()
	_ = yym1670
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1671 := r.ContainerType()
		if yyct1671 == codecSelferValueTypeMap1234 {
			yyl1671 := r.ReadMapStart()
			if yyl1671 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1671, d)
			}
		} else if yyct1671 == codecSelferValueTypeArray1234 {
			yyl1671 := r.ReadArrayStart()
			if yyl1671 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1671, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1672Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1672Slc
	var yyhl1672 bool = l >= 0
	for yyj1672 := 0; ; yyj1672++ {
		if yyhl1672 {
			if yyj1672 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1672Slc = r.DecodeBytes(yys1672Slc, true, true)
		yys1672 := string(yys1672Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1672 {
		case "protocol":
			if r.TryDecodeAsNil() {
				if x.Protocol != nil {
					x.Protocol = nil
				}
			} else {
				if x.Protocol == nil {
					x.Protocol = new(pkg2_v1.Protocol)
				}
				x.Protocol.CodecDecodeSelf(d)
			}
		case "port":
			if r.TryDecodeAsNil() {
				if x.Port != nil {
					x.Port = nil
				}
			} else {
				if x.Port == nil {
					x.Port = new(pkg5_intstr.IntOrString)
				}
				yym1675 := z.DecBinary()
				_ = yym1675
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Port) {
				} else if !yym1675 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Port)
				} else {
					z.DecFallback(x.Port, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1672)
		} // end switch yys1672
	} // end for yyj1672
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1676 int
	var yyb1676 bool
	var yyhl1676 bool = l >= 0
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Protocol != nil {
			x.Protocol = nil
		}
	} else {
		if x.Protocol == nil {
			x.Protocol = new(pkg2_v1.Protocol)
		}
		x.Protocol.CodecDecodeSelf(d)
	}
	yyj1676++
	if yyhl1676 {
		yyb1676 = yyj1676 > l
	} else {
		yyb1676 = r.CheckBreak()
	}
	if yyb1676 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.Port != nil {
			x.Port = nil
		}
	} else {
		if x.Port == nil {
			x.Port = new(pkg5_intstr.IntOrString)
		}
		yym1679 := z.DecBinary()
		_ = yym1679
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Port) {
		} else if !yym1679 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Port)
		} else {
			z.DecFallback(x.Port, false)
		}
	}
	for {
		yyj1676++
		if yyhl1676 {
			yyb1676 = yyj1676 > l
		} else {
			yyb1676 = r.CheckBreak()
		}
		if yyb1676 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1676-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyPeer) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1680 := z.EncBinary()
		_ = yym1680
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1681 := !z.EncBinary()
			yy2arr1681 := z.EncBasicHandle().StructToArray
			var yyq1681 [2]bool
			_, _, _ = yysep1681, yyq1681, yy2arr1681
			const yyr1681 bool = false
			yyq1681[0] = x.PodSelector != nil
			yyq1681[1] = x.NamespaceSelector != nil
			var yynn1681 int
			if yyr1681 || yy2arr1681 {
				r.EncodeArrayStart(2)
			} else {
				yynn1681 = 0
				for _, b := range yyq1681 {
					if b {
						yynn1681++
					}
				}
				r.EncodeMapStart(yynn1681)
				yynn1681 = 0
			}
			if yyr1681 || yy2arr1681 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1681[0] {
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						x.PodSelector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1681[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						x.PodSelector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1681 || yy2arr1681 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1681[1] {
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						x.NamespaceSelector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1681[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("namespaceSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						x.NamespaceSelector.CodecEncodeSelf(e)
					}
				}
			}
			if yyr1681 || yy2arr1681 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyPeer) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1684 := z.DecBinary()
	_ = yym1684
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1685 := r.ContainerType()
		if yyct1685 == codecSelferValueTypeMap1234 {
			yyl1685 := r.ReadMapStart()
			if yyl1685 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1685, d)
			}
		} else if yyct1685 == codecSelferValueTypeArray1234 {
			yyl1685 := r.ReadArrayStart()
			if yyl1685 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1685, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyPeer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1686Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1686Slc
	var yyhl1686 bool = l >= 0
	for yyj1686 := 0; ; yyj1686++ {
		if yyhl1686 {
			if yyj1686 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1686Slc = r.DecodeBytes(yys1686Slc, true, true)
		yys1686 := string(yys1686Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1686 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				if x.PodSelector != nil {
					x.PodSelector = nil
				}
			} else {
				if x.PodSelector == nil {
					x.PodSelector = new(LabelSelector)
				}
				x.PodSelector.CodecDecodeSelf(d)
			}
		case "namespaceSelector":
			if r.TryDecodeAsNil() {
				if x.NamespaceSelector != nil {
					x.NamespaceSelector = nil
				}
			} else {
				if x.NamespaceSelector == nil {
					x.NamespaceSelector = new(LabelSelector)
				}
				x.NamespaceSelector.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1686)
		} // end switch yys1686
	} // end for yyj1686
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyPeer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1689 int
	var yyb1689 bool
	var yyhl1689 bool = l >= 0
	yyj1689++
	if yyhl1689 {
		yyb1689 = yyj1689 > l
	} else {
		yyb1689 = r.CheckBreak()
	}
	if yyb1689 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.PodSelector != nil {
			x.PodSelector = nil
		}
	} else {
		if x.PodSelector == nil {
			x.PodSelector = new(LabelSelector)
		}
		x.PodSelector.CodecDecodeSelf(d)
	}
	yyj1689++
	if yyhl1689 {
		yyb1689 = yyj1689 > l
	} else {
		yyb1689 = r.CheckBreak()
	}
	if yyb1689 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.NamespaceSelector != nil {
			x.NamespaceSelector = nil
		}
	} else {
		if x.NamespaceSelector == nil {
			x.NamespaceSelector = new(LabelSelector)
		}
		x.NamespaceSelector.CodecDecodeSelf(d)
	}
	for {
		yyj1689++
		if yyhl1689 {
			yyb1689 = yyj1689 > l
		} else {
			yyb1689 = r.CheckBreak()
		}
		if yyb1689 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1689-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NetworkPolicyList) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1692 := z.EncBinary()
		_ = yym1692
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1693 := !z.EncBinary()
			yy2arr1693 := z.EncBasicHandle().StructToArray
			var yyq1693 [4]bool
			_, _, _ = yysep1693, yyq1693, yy2arr1693
			const yyr1693 bool = false
			yyq1693[0] = x.Kind != ""
			yyq1693[1] = x.APIVersion != ""
			yyq1693[2] = true
			var yynn1693 int
			if yyr1693 || yy2arr1693 {
				r.EncodeArrayStart(4)
			} else {
				yynn1693 = 1
				for _, b := range yyq1693 {
					if b {
						yynn1693++
					}
				}
				r.EncodeMapStart(yynn1693)
				yynn1693 = 0
			}
			if yyr1693 || yy2arr1693 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1693[0] {
					yym1695 := z.EncBinary()
					_ = yym1695
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1693[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1696 := z.EncBinary()
					_ = yym1696
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1693 || yy2arr1693 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1693[1] {
					yym1698 := z.EncBinary()
					_ = yym1698
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1693[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1699 := z.EncBinary()
					_ = yym1699
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1693 || yy2arr1693 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1693[2] {
					yy1701 := &x.ListMeta
					yym1702 := z.EncBinary()
					_ = yym1702
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1701) {
					} else {
						z.EncFallback(yy1701)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1693[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1703 := &x.ListMeta
					yym1704 := z.EncBinary()
					_ = yym1704
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1703) {
					} else {
						z.EncFallback(yy1703)
					}
				}
			}
			if yyr1693 || yy2arr1693 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1706 := z.EncBinary()
					_ = yym1706
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("items"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1707 := z.EncBinary()
					_ = yym1707
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			}
			if yyr1693 || yy2arr1693 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NetworkPolicyList) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1708 := z.DecBinary()
	_ = yym1708
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1709 := r.ContainerType()
		if yyct1709 == codecSelferValueTypeMap1234 {
			yyl1709 := r.ReadMapStart()
			if yyl1709 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1709, d)
			}
		} else if yyct1709 == codecSelferValueTypeArray1234 {
			yyl1709 := r.ReadArrayStart()
			if yyl1709 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1709, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1710Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1710Slc
	var yyhl1710 bool = l >= 0
	for yyj1710 := 0; ; yyj1710++ {
		if yyhl1710 {
			if yyj1710 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1710Slc = r.DecodeBytes(yys1710Slc, true, true)
		yys1710 := string(yys1710Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1710 {
		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 {
				yyv1713 := &x.ListMeta
				yym1714 := z.DecBinary()
				_ = yym1714
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1713) {
				} else {
					z.DecFallback(yyv1713, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1715 := &x.Items
				yym1716 := z.DecBinary()
				_ = yym1716
				if false {
				} else {
					h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1715), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1710)
		} // end switch yys1710
	} // end for yyj1710
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NetworkPolicyList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1717 int
	var yyb1717 bool
	var yyhl1717 bool = l >= 0
	yyj1717++
	if yyhl1717 {
		yyb1717 = yyj1717 > l
	} else {
		yyb1717 = r.CheckBreak()
	}
	if yyb1717 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1717++
	if yyhl1717 {
		yyb1717 = yyj1717 > l
	} else {
		yyb1717 = r.CheckBreak()
	}
	if yyb1717 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1717++
	if yyhl1717 {
		yyb1717 = yyj1717 > l
	} else {
		yyb1717 = r.CheckBreak()
	}
	if yyb1717 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1720 := &x.ListMeta
		yym1721 := z.DecBinary()
		_ = yym1721
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1720) {
		} else {
			z.DecFallback(yyv1720, false)
		}
	}
	yyj1717++
	if yyhl1717 {
		yyb1717 = yyj1717 > l
	} else {
		yyb1717 = r.CheckBreak()
	}
	if yyb1717 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1722 := &x.Items
		yym1723 := z.DecBinary()
		_ = yym1723
		if false {
		} else {
			h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1722), d)
		}
	}
	for {
		yyj1717++
		if yyhl1717 {
			yyb1717 = yyj1717 > l
		} else {
			yyb1717 = r.CheckBreak()
		}
		if yyb1717 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1717-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x codecSelfer1234) encSliceCustomMetricTarget(v []CustomMetricTarget, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1724 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1725 := &yyv1724
		yy1725.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1726 := *v
	yyh1726, yyl1726 := z.DecSliceHelperStart()
	var yyc1726 bool
	if yyl1726 == 0 {
		if yyv1726 == nil {
			yyv1726 = []CustomMetricTarget{}
			yyc1726 = true
		} else if len(yyv1726) != 0 {
			yyv1726 = yyv1726[:0]
			yyc1726 = true
		}
	} else if yyl1726 > 0 {
		var yyrr1726, yyrl1726 int
		var yyrt1726 bool
		if yyl1726 > cap(yyv1726) {

			yyrg1726 := len(yyv1726) > 0
			yyv21726 := yyv1726
			yyrl1726, yyrt1726 = z.DecInferLen(yyl1726, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1726 {
				if yyrl1726 <= cap(yyv1726) {
					yyv1726 = yyv1726[:yyrl1726]
				} else {
					yyv1726 = make([]CustomMetricTarget, yyrl1726)
				}
			} else {
				yyv1726 = make([]CustomMetricTarget, yyrl1726)
			}
			yyc1726 = true
			yyrr1726 = len(yyv1726)
			if yyrg1726 {
				copy(yyv1726, yyv21726)
			}
		} else if yyl1726 != len(yyv1726) {
			yyv1726 = yyv1726[:yyl1726]
			yyc1726 = true
		}
		yyj1726 := 0
		for ; yyj1726 < yyrr1726; yyj1726++ {
			yyh1726.ElemContainerState(yyj1726)
			if r.TryDecodeAsNil() {
				yyv1726[yyj1726] = CustomMetricTarget{}
			} else {
				yyv1727 := &yyv1726[yyj1726]
				yyv1727.CodecDecodeSelf(d)
			}

		}
		if yyrt1726 {
			for ; yyj1726 < yyl1726; yyj1726++ {
				yyv1726 = append(yyv1726, CustomMetricTarget{})
				yyh1726.ElemContainerState(yyj1726)
				if r.TryDecodeAsNil() {
					yyv1726[yyj1726] = CustomMetricTarget{}
				} else {
					yyv1728 := &yyv1726[yyj1726]
					yyv1728.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1726 := 0
		for ; !r.CheckBreak(); yyj1726++ {

			if yyj1726 >= len(yyv1726) {
				yyv1726 = append(yyv1726, CustomMetricTarget{}) // var yyz1726 CustomMetricTarget
				yyc1726 = true
			}
			yyh1726.ElemContainerState(yyj1726)
			if yyj1726 < len(yyv1726) {
				if r.TryDecodeAsNil() {
					yyv1726[yyj1726] = CustomMetricTarget{}
				} else {
					yyv1729 := &yyv1726[yyj1726]
					yyv1729.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1726 < len(yyv1726) {
			yyv1726 = yyv1726[:yyj1726]
			yyc1726 = true
		} else if yyj1726 == 0 && yyv1726 == nil {
			yyv1726 = []CustomMetricTarget{}
			yyc1726 = true
		}
	}
	yyh1726.End()
	if yyc1726 {
		*v = yyv1726
	}
}

func (x codecSelfer1234) encSliceCustomMetricCurrentStatus(v []CustomMetricCurrentStatus, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1730 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1731 := &yyv1730
		yy1731.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1732 := *v
	yyh1732, yyl1732 := z.DecSliceHelperStart()
	var yyc1732 bool
	if yyl1732 == 0 {
		if yyv1732 == nil {
			yyv1732 = []CustomMetricCurrentStatus{}
			yyc1732 = true
		} else if len(yyv1732) != 0 {
			yyv1732 = yyv1732[:0]
			yyc1732 = true
		}
	} else if yyl1732 > 0 {
		var yyrr1732, yyrl1732 int
		var yyrt1732 bool
		if yyl1732 > cap(yyv1732) {

			yyrg1732 := len(yyv1732) > 0
			yyv21732 := yyv1732
			yyrl1732, yyrt1732 = z.DecInferLen(yyl1732, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1732 {
				if yyrl1732 <= cap(yyv1732) {
					yyv1732 = yyv1732[:yyrl1732]
				} else {
					yyv1732 = make([]CustomMetricCurrentStatus, yyrl1732)
				}
			} else {
				yyv1732 = make([]CustomMetricCurrentStatus, yyrl1732)
			}
			yyc1732 = true
			yyrr1732 = len(yyv1732)
			if yyrg1732 {
				copy(yyv1732, yyv21732)
			}
		} else if yyl1732 != len(yyv1732) {
			yyv1732 = yyv1732[:yyl1732]
			yyc1732 = true
		}
		yyj1732 := 0
		for ; yyj1732 < yyrr1732; yyj1732++ {
			yyh1732.ElemContainerState(yyj1732)
			if r.TryDecodeAsNil() {
				yyv1732[yyj1732] = CustomMetricCurrentStatus{}
			} else {
				yyv1733 := &yyv1732[yyj1732]
				yyv1733.CodecDecodeSelf(d)
			}

		}
		if yyrt1732 {
			for ; yyj1732 < yyl1732; yyj1732++ {
				yyv1732 = append(yyv1732, CustomMetricCurrentStatus{})
				yyh1732.ElemContainerState(yyj1732)
				if r.TryDecodeAsNil() {
					yyv1732[yyj1732] = CustomMetricCurrentStatus{}
				} else {
					yyv1734 := &yyv1732[yyj1732]
					yyv1734.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1732 := 0
		for ; !r.CheckBreak(); yyj1732++ {

			if yyj1732 >= len(yyv1732) {
				yyv1732 = append(yyv1732, CustomMetricCurrentStatus{}) // var yyz1732 CustomMetricCurrentStatus
				yyc1732 = true
			}
			yyh1732.ElemContainerState(yyj1732)
			if yyj1732 < len(yyv1732) {
				if r.TryDecodeAsNil() {
					yyv1732[yyj1732] = CustomMetricCurrentStatus{}
				} else {
					yyv1735 := &yyv1732[yyj1732]
					yyv1735.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1732 < len(yyv1732) {
			yyv1732 = yyv1732[:yyj1732]
			yyc1732 = true
		} else if yyj1732 == 0 && yyv1732 == nil {
			yyv1732 = []CustomMetricCurrentStatus{}
			yyc1732 = true
		}
	}
	yyh1732.End()
	if yyc1732 {
		*v = yyv1732
	}
}

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 _, yyv1736 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1737 := &yyv1736
		yy1737.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1738 := *v
	yyh1738, yyl1738 := z.DecSliceHelperStart()
	var yyc1738 bool
	if yyl1738 == 0 {
		if yyv1738 == nil {
			yyv1738 = []HorizontalPodAutoscaler{}
			yyc1738 = true
		} else if len(yyv1738) != 0 {
			yyv1738 = yyv1738[:0]
			yyc1738 = true
		}
	} else if yyl1738 > 0 {
		var yyrr1738, yyrl1738 int
		var yyrt1738 bool
		if yyl1738 > cap(yyv1738) {

			yyrg1738 := len(yyv1738) > 0
			yyv21738 := yyv1738
			yyrl1738, yyrt1738 = z.DecInferLen(yyl1738, z.DecBasicHandle().MaxInitLen, 376)
			if yyrt1738 {
				if yyrl1738 <= cap(yyv1738) {
					yyv1738 = yyv1738[:yyrl1738]
				} else {
					yyv1738 = make([]HorizontalPodAutoscaler, yyrl1738)
				}
			} else {
				yyv1738 = make([]HorizontalPodAutoscaler, yyrl1738)
			}
			yyc1738 = true
			yyrr1738 = len(yyv1738)
			if yyrg1738 {
				copy(yyv1738, yyv21738)
			}
		} else if yyl1738 != len(yyv1738) {
			yyv1738 = yyv1738[:yyl1738]
			yyc1738 = true
		}
		yyj1738 := 0
		for ; yyj1738 < yyrr1738; yyj1738++ {
			yyh1738.ElemContainerState(yyj1738)
			if r.TryDecodeAsNil() {
				yyv1738[yyj1738] = HorizontalPodAutoscaler{}
			} else {
				yyv1739 := &yyv1738[yyj1738]
				yyv1739.CodecDecodeSelf(d)
			}

		}
		if yyrt1738 {
			for ; yyj1738 < yyl1738; yyj1738++ {
				yyv1738 = append(yyv1738, HorizontalPodAutoscaler{})
				yyh1738.ElemContainerState(yyj1738)
				if r.TryDecodeAsNil() {
					yyv1738[yyj1738] = HorizontalPodAutoscaler{}
				} else {
					yyv1740 := &yyv1738[yyj1738]
					yyv1740.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1738 := 0
		for ; !r.CheckBreak(); yyj1738++ {

			if yyj1738 >= len(yyv1738) {
				yyv1738 = append(yyv1738, HorizontalPodAutoscaler{}) // var yyz1738 HorizontalPodAutoscaler
				yyc1738 = true
			}
			yyh1738.ElemContainerState(yyj1738)
			if yyj1738 < len(yyv1738) {
				if r.TryDecodeAsNil() {
					yyv1738[yyj1738] = HorizontalPodAutoscaler{}
				} else {
					yyv1741 := &yyv1738[yyj1738]
					yyv1741.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1738 < len(yyv1738) {
			yyv1738 = yyv1738[:yyj1738]
			yyc1738 = true
		} else if yyj1738 == 0 && yyv1738 == nil {
			yyv1738 = []HorizontalPodAutoscaler{}
			yyc1738 = true
		}
	}
	yyh1738.End()
	if yyc1738 {
		*v = yyv1738
	}
}

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 _, yyv1742 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1743 := &yyv1742
		yy1743.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1744 := *v
	yyh1744, yyl1744 := z.DecSliceHelperStart()
	var yyc1744 bool
	if yyl1744 == 0 {
		if yyv1744 == nil {
			yyv1744 = []APIVersion{}
			yyc1744 = true
		} else if len(yyv1744) != 0 {
			yyv1744 = yyv1744[:0]
			yyc1744 = true
		}
	} else if yyl1744 > 0 {
		var yyrr1744, yyrl1744 int
		var yyrt1744 bool
		if yyl1744 > cap(yyv1744) {

			yyrg1744 := len(yyv1744) > 0
			yyv21744 := yyv1744
			yyrl1744, yyrt1744 = z.DecInferLen(yyl1744, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1744 {
				if yyrl1744 <= cap(yyv1744) {
					yyv1744 = yyv1744[:yyrl1744]
				} else {
					yyv1744 = make([]APIVersion, yyrl1744)
				}
			} else {
				yyv1744 = make([]APIVersion, yyrl1744)
			}
			yyc1744 = true
			yyrr1744 = len(yyv1744)
			if yyrg1744 {
				copy(yyv1744, yyv21744)
			}
		} else if yyl1744 != len(yyv1744) {
			yyv1744 = yyv1744[:yyl1744]
			yyc1744 = true
		}
		yyj1744 := 0
		for ; yyj1744 < yyrr1744; yyj1744++ {
			yyh1744.ElemContainerState(yyj1744)
			if r.TryDecodeAsNil() {
				yyv1744[yyj1744] = APIVersion{}
			} else {
				yyv1745 := &yyv1744[yyj1744]
				yyv1745.CodecDecodeSelf(d)
			}

		}
		if yyrt1744 {
			for ; yyj1744 < yyl1744; yyj1744++ {
				yyv1744 = append(yyv1744, APIVersion{})
				yyh1744.ElemContainerState(yyj1744)
				if r.TryDecodeAsNil() {
					yyv1744[yyj1744] = APIVersion{}
				} else {
					yyv1746 := &yyv1744[yyj1744]
					yyv1746.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1744 := 0
		for ; !r.CheckBreak(); yyj1744++ {

			if yyj1744 >= len(yyv1744) {
				yyv1744 = append(yyv1744, APIVersion{}) // var yyz1744 APIVersion
				yyc1744 = true
			}
			yyh1744.ElemContainerState(yyj1744)
			if yyj1744 < len(yyv1744) {
				if r.TryDecodeAsNil() {
					yyv1744[yyj1744] = APIVersion{}
				} else {
					yyv1747 := &yyv1744[yyj1744]
					yyv1747.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1744 < len(yyv1744) {
			yyv1744 = yyv1744[:yyj1744]
			yyc1744 = true
		} else if yyj1744 == 0 && yyv1744 == nil {
			yyv1744 = []APIVersion{}
			yyc1744 = true
		}
	}
	yyh1744.End()
	if yyc1744 {
		*v = yyv1744
	}
}

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 _, yyv1748 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1749 := &yyv1748
		yy1749.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1750 := *v
	yyh1750, yyl1750 := z.DecSliceHelperStart()
	var yyc1750 bool
	if yyl1750 == 0 {
		if yyv1750 == nil {
			yyv1750 = []ThirdPartyResource{}
			yyc1750 = true
		} else if len(yyv1750) != 0 {
			yyv1750 = yyv1750[:0]
			yyc1750 = true
		}
	} else if yyl1750 > 0 {
		var yyrr1750, yyrl1750 int
		var yyrt1750 bool
		if yyl1750 > cap(yyv1750) {

			yyrg1750 := len(yyv1750) > 0
			yyv21750 := yyv1750
			yyrl1750, yyrt1750 = z.DecInferLen(yyl1750, z.DecBasicHandle().MaxInitLen, 296)
			if yyrt1750 {
				if yyrl1750 <= cap(yyv1750) {
					yyv1750 = yyv1750[:yyrl1750]
				} else {
					yyv1750 = make([]ThirdPartyResource, yyrl1750)
				}
			} else {
				yyv1750 = make([]ThirdPartyResource, yyrl1750)
			}
			yyc1750 = true
			yyrr1750 = len(yyv1750)
			if yyrg1750 {
				copy(yyv1750, yyv21750)
			}
		} else if yyl1750 != len(yyv1750) {
			yyv1750 = yyv1750[:yyl1750]
			yyc1750 = true
		}
		yyj1750 := 0
		for ; yyj1750 < yyrr1750; yyj1750++ {
			yyh1750.ElemContainerState(yyj1750)
			if r.TryDecodeAsNil() {
				yyv1750[yyj1750] = ThirdPartyResource{}
			} else {
				yyv1751 := &yyv1750[yyj1750]
				yyv1751.CodecDecodeSelf(d)
			}

		}
		if yyrt1750 {
			for ; yyj1750 < yyl1750; yyj1750++ {
				yyv1750 = append(yyv1750, ThirdPartyResource{})
				yyh1750.ElemContainerState(yyj1750)
				if r.TryDecodeAsNil() {
					yyv1750[yyj1750] = ThirdPartyResource{}
				} else {
					yyv1752 := &yyv1750[yyj1750]
					yyv1752.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1750 := 0
		for ; !r.CheckBreak(); yyj1750++ {

			if yyj1750 >= len(yyv1750) {
				yyv1750 = append(yyv1750, ThirdPartyResource{}) // var yyz1750 ThirdPartyResource
				yyc1750 = true
			}
			yyh1750.ElemContainerState(yyj1750)
			if yyj1750 < len(yyv1750) {
				if r.TryDecodeAsNil() {
					yyv1750[yyj1750] = ThirdPartyResource{}
				} else {
					yyv1753 := &yyv1750[yyj1750]
					yyv1753.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1750 < len(yyv1750) {
			yyv1750 = yyv1750[:yyj1750]
			yyc1750 = true
		} else if yyj1750 == 0 && yyv1750 == nil {
			yyv1750 = []ThirdPartyResource{}
			yyc1750 = true
		}
	}
	yyh1750.End()
	if yyc1750 {
		*v = yyv1750
	}
}

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 _, yyv1754 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1755 := &yyv1754
		yy1755.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1756 := *v
	yyh1756, yyl1756 := z.DecSliceHelperStart()
	var yyc1756 bool
	if yyl1756 == 0 {
		if yyv1756 == nil {
			yyv1756 = []Deployment{}
			yyc1756 = true
		} else if len(yyv1756) != 0 {
			yyv1756 = yyv1756[:0]
			yyc1756 = true
		}
	} else if yyl1756 > 0 {
		var yyrr1756, yyrl1756 int
		var yyrt1756 bool
		if yyl1756 > cap(yyv1756) {

			yyrg1756 := len(yyv1756) > 0
			yyv21756 := yyv1756
			yyrl1756, yyrt1756 = z.DecInferLen(yyl1756, z.DecBasicHandle().MaxInitLen, 824)
			if yyrt1756 {
				if yyrl1756 <= cap(yyv1756) {
					yyv1756 = yyv1756[:yyrl1756]
				} else {
					yyv1756 = make([]Deployment, yyrl1756)
				}
			} else {
				yyv1756 = make([]Deployment, yyrl1756)
			}
			yyc1756 = true
			yyrr1756 = len(yyv1756)
			if yyrg1756 {
				copy(yyv1756, yyv21756)
			}
		} else if yyl1756 != len(yyv1756) {
			yyv1756 = yyv1756[:yyl1756]
			yyc1756 = true
		}
		yyj1756 := 0
		for ; yyj1756 < yyrr1756; yyj1756++ {
			yyh1756.ElemContainerState(yyj1756)
			if r.TryDecodeAsNil() {
				yyv1756[yyj1756] = Deployment{}
			} else {
				yyv1757 := &yyv1756[yyj1756]
				yyv1757.CodecDecodeSelf(d)
			}

		}
		if yyrt1756 {
			for ; yyj1756 < yyl1756; yyj1756++ {
				yyv1756 = append(yyv1756, Deployment{})
				yyh1756.ElemContainerState(yyj1756)
				if r.TryDecodeAsNil() {
					yyv1756[yyj1756] = Deployment{}
				} else {
					yyv1758 := &yyv1756[yyj1756]
					yyv1758.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1756 := 0
		for ; !r.CheckBreak(); yyj1756++ {

			if yyj1756 >= len(yyv1756) {
				yyv1756 = append(yyv1756, Deployment{}) // var yyz1756 Deployment
				yyc1756 = true
			}
			yyh1756.ElemContainerState(yyj1756)
			if yyj1756 < len(yyv1756) {
				if r.TryDecodeAsNil() {
					yyv1756[yyj1756] = Deployment{}
				} else {
					yyv1759 := &yyv1756[yyj1756]
					yyv1759.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1756 < len(yyv1756) {
			yyv1756 = yyv1756[:yyj1756]
			yyc1756 = true
		} else if yyj1756 == 0 && yyv1756 == nil {
			yyv1756 = []Deployment{}
			yyc1756 = true
		}
	}
	yyh1756.End()
	if yyc1756 {
		*v = yyv1756
	}
}

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 _, yyv1760 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1761 := &yyv1760
		yy1761.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1762 := *v
	yyh1762, yyl1762 := z.DecSliceHelperStart()
	var yyc1762 bool
	if yyl1762 == 0 {
		if yyv1762 == nil {
			yyv1762 = []DaemonSet{}
			yyc1762 = true
		} else if len(yyv1762) != 0 {
			yyv1762 = yyv1762[:0]
			yyc1762 = true
		}
	} else if yyl1762 > 0 {
		var yyrr1762, yyrl1762 int
		var yyrt1762 bool
		if yyl1762 > cap(yyv1762) {

			yyrg1762 := len(yyv1762) > 0
			yyv21762 := yyv1762
			yyrl1762, yyrt1762 = z.DecInferLen(yyl1762, z.DecBasicHandle().MaxInitLen, 752)
			if yyrt1762 {
				if yyrl1762 <= cap(yyv1762) {
					yyv1762 = yyv1762[:yyrl1762]
				} else {
					yyv1762 = make([]DaemonSet, yyrl1762)
				}
			} else {
				yyv1762 = make([]DaemonSet, yyrl1762)
			}
			yyc1762 = true
			yyrr1762 = len(yyv1762)
			if yyrg1762 {
				copy(yyv1762, yyv21762)
			}
		} else if yyl1762 != len(yyv1762) {
			yyv1762 = yyv1762[:yyl1762]
			yyc1762 = true
		}
		yyj1762 := 0
		for ; yyj1762 < yyrr1762; yyj1762++ {
			yyh1762.ElemContainerState(yyj1762)
			if r.TryDecodeAsNil() {
				yyv1762[yyj1762] = DaemonSet{}
			} else {
				yyv1763 := &yyv1762[yyj1762]
				yyv1763.CodecDecodeSelf(d)
			}

		}
		if yyrt1762 {
			for ; yyj1762 < yyl1762; yyj1762++ {
				yyv1762 = append(yyv1762, DaemonSet{})
				yyh1762.ElemContainerState(yyj1762)
				if r.TryDecodeAsNil() {
					yyv1762[yyj1762] = DaemonSet{}
				} else {
					yyv1764 := &yyv1762[yyj1762]
					yyv1764.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1762 := 0
		for ; !r.CheckBreak(); yyj1762++ {

			if yyj1762 >= len(yyv1762) {
				yyv1762 = append(yyv1762, DaemonSet{}) // var yyz1762 DaemonSet
				yyc1762 = true
			}
			yyh1762.ElemContainerState(yyj1762)
			if yyj1762 < len(yyv1762) {
				if r.TryDecodeAsNil() {
					yyv1762[yyj1762] = DaemonSet{}
				} else {
					yyv1765 := &yyv1762[yyj1762]
					yyv1765.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1762 < len(yyv1762) {
			yyv1762 = yyv1762[:yyj1762]
			yyc1762 = true
		} else if yyj1762 == 0 && yyv1762 == nil {
			yyv1762 = []DaemonSet{}
			yyc1762 = true
		}
	}
	yyh1762.End()
	if yyc1762 {
		*v = yyv1762
	}
}

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 _, yyv1766 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1767 := &yyv1766
		yy1767.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1768 := *v
	yyh1768, yyl1768 := z.DecSliceHelperStart()
	var yyc1768 bool
	if yyl1768 == 0 {
		if yyv1768 == nil {
			yyv1768 = []ThirdPartyResourceData{}
			yyc1768 = true
		} else if len(yyv1768) != 0 {
			yyv1768 = yyv1768[:0]
			yyc1768 = true
		}
	} else if yyl1768 > 0 {
		var yyrr1768, yyrl1768 int
		var yyrt1768 bool
		if yyl1768 > cap(yyv1768) {

			yyrg1768 := len(yyv1768) > 0
			yyv21768 := yyv1768
			yyrl1768, yyrt1768 = z.DecInferLen(yyl1768, z.DecBasicHandle().MaxInitLen, 280)
			if yyrt1768 {
				if yyrl1768 <= cap(yyv1768) {
					yyv1768 = yyv1768[:yyrl1768]
				} else {
					yyv1768 = make([]ThirdPartyResourceData, yyrl1768)
				}
			} else {
				yyv1768 = make([]ThirdPartyResourceData, yyrl1768)
			}
			yyc1768 = true
			yyrr1768 = len(yyv1768)
			if yyrg1768 {
				copy(yyv1768, yyv21768)
			}
		} else if yyl1768 != len(yyv1768) {
			yyv1768 = yyv1768[:yyl1768]
			yyc1768 = true
		}
		yyj1768 := 0
		for ; yyj1768 < yyrr1768; yyj1768++ {
			yyh1768.ElemContainerState(yyj1768)
			if r.TryDecodeAsNil() {
				yyv1768[yyj1768] = ThirdPartyResourceData{}
			} else {
				yyv1769 := &yyv1768[yyj1768]
				yyv1769.CodecDecodeSelf(d)
			}

		}
		if yyrt1768 {
			for ; yyj1768 < yyl1768; yyj1768++ {
				yyv1768 = append(yyv1768, ThirdPartyResourceData{})
				yyh1768.ElemContainerState(yyj1768)
				if r.TryDecodeAsNil() {
					yyv1768[yyj1768] = ThirdPartyResourceData{}
				} else {
					yyv1770 := &yyv1768[yyj1768]
					yyv1770.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1768 := 0
		for ; !r.CheckBreak(); yyj1768++ {

			if yyj1768 >= len(yyv1768) {
				yyv1768 = append(yyv1768, ThirdPartyResourceData{}) // var yyz1768 ThirdPartyResourceData
				yyc1768 = true
			}
			yyh1768.ElemContainerState(yyj1768)
			if yyj1768 < len(yyv1768) {
				if r.TryDecodeAsNil() {
					yyv1768[yyj1768] = ThirdPartyResourceData{}
				} else {
					yyv1771 := &yyv1768[yyj1768]
					yyv1771.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1768 < len(yyv1768) {
			yyv1768 = yyv1768[:yyj1768]
			yyc1768 = true
		} else if yyj1768 == 0 && yyv1768 == nil {
			yyv1768 = []ThirdPartyResourceData{}
			yyc1768 = true
		}
	}
	yyh1768.End()
	if yyc1768 {
		*v = yyv1768
	}
}

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 _, yyv1772 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1773 := &yyv1772
		yy1773.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1774 := *v
	yyh1774, yyl1774 := z.DecSliceHelperStart()
	var yyc1774 bool
	if yyl1774 == 0 {
		if yyv1774 == nil {
			yyv1774 = []Job{}
			yyc1774 = true
		} else if len(yyv1774) != 0 {
			yyv1774 = yyv1774[:0]
			yyc1774 = true
		}
	} else if yyl1774 > 0 {
		var yyrr1774, yyrl1774 int
		var yyrt1774 bool
		if yyl1774 > cap(yyv1774) {

			yyrg1774 := len(yyv1774) > 0
			yyv21774 := yyv1774
			yyrl1774, yyrt1774 = z.DecInferLen(yyl1774, z.DecBasicHandle().MaxInitLen, 824)
			if yyrt1774 {
				if yyrl1774 <= cap(yyv1774) {
					yyv1774 = yyv1774[:yyrl1774]
				} else {
					yyv1774 = make([]Job, yyrl1774)
				}
			} else {
				yyv1774 = make([]Job, yyrl1774)
			}
			yyc1774 = true
			yyrr1774 = len(yyv1774)
			if yyrg1774 {
				copy(yyv1774, yyv21774)
			}
		} else if yyl1774 != len(yyv1774) {
			yyv1774 = yyv1774[:yyl1774]
			yyc1774 = true
		}
		yyj1774 := 0
		for ; yyj1774 < yyrr1774; yyj1774++ {
			yyh1774.ElemContainerState(yyj1774)
			if r.TryDecodeAsNil() {
				yyv1774[yyj1774] = Job{}
			} else {
				yyv1775 := &yyv1774[yyj1774]
				yyv1775.CodecDecodeSelf(d)
			}

		}
		if yyrt1774 {
			for ; yyj1774 < yyl1774; yyj1774++ {
				yyv1774 = append(yyv1774, Job{})
				yyh1774.ElemContainerState(yyj1774)
				if r.TryDecodeAsNil() {
					yyv1774[yyj1774] = Job{}
				} else {
					yyv1776 := &yyv1774[yyj1774]
					yyv1776.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1774 := 0
		for ; !r.CheckBreak(); yyj1774++ {

			if yyj1774 >= len(yyv1774) {
				yyv1774 = append(yyv1774, Job{}) // var yyz1774 Job
				yyc1774 = true
			}
			yyh1774.ElemContainerState(yyj1774)
			if yyj1774 < len(yyv1774) {
				if r.TryDecodeAsNil() {
					yyv1774[yyj1774] = Job{}
				} else {
					yyv1777 := &yyv1774[yyj1774]
					yyv1777.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1774 < len(yyv1774) {
			yyv1774 = yyv1774[:yyj1774]
			yyc1774 = true
		} else if yyj1774 == 0 && yyv1774 == nil {
			yyv1774 = []Job{}
			yyc1774 = true
		}
	}
	yyh1774.End()
	if yyc1774 {
		*v = yyv1774
	}
}

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 _, yyv1778 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1779 := &yyv1778
		yy1779.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1780 := *v
	yyh1780, yyl1780 := z.DecSliceHelperStart()
	var yyc1780 bool
	if yyl1780 == 0 {
		if yyv1780 == nil {
			yyv1780 = []JobCondition{}
			yyc1780 = true
		} else if len(yyv1780) != 0 {
			yyv1780 = yyv1780[:0]
			yyc1780 = true
		}
	} else if yyl1780 > 0 {
		var yyrr1780, yyrl1780 int
		var yyrt1780 bool
		if yyl1780 > cap(yyv1780) {

			yyrg1780 := len(yyv1780) > 0
			yyv21780 := yyv1780
			yyrl1780, yyrt1780 = z.DecInferLen(yyl1780, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1780 {
				if yyrl1780 <= cap(yyv1780) {
					yyv1780 = yyv1780[:yyrl1780]
				} else {
					yyv1780 = make([]JobCondition, yyrl1780)
				}
			} else {
				yyv1780 = make([]JobCondition, yyrl1780)
			}
			yyc1780 = true
			yyrr1780 = len(yyv1780)
			if yyrg1780 {
				copy(yyv1780, yyv21780)
			}
		} else if yyl1780 != len(yyv1780) {
			yyv1780 = yyv1780[:yyl1780]
			yyc1780 = true
		}
		yyj1780 := 0
		for ; yyj1780 < yyrr1780; yyj1780++ {
			yyh1780.ElemContainerState(yyj1780)
			if r.TryDecodeAsNil() {
				yyv1780[yyj1780] = JobCondition{}
			} else {
				yyv1781 := &yyv1780[yyj1780]
				yyv1781.CodecDecodeSelf(d)
			}

		}
		if yyrt1780 {
			for ; yyj1780 < yyl1780; yyj1780++ {
				yyv1780 = append(yyv1780, JobCondition{})
				yyh1780.ElemContainerState(yyj1780)
				if r.TryDecodeAsNil() {
					yyv1780[yyj1780] = JobCondition{}
				} else {
					yyv1782 := &yyv1780[yyj1780]
					yyv1782.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1780 := 0
		for ; !r.CheckBreak(); yyj1780++ {

			if yyj1780 >= len(yyv1780) {
				yyv1780 = append(yyv1780, JobCondition{}) // var yyz1780 JobCondition
				yyc1780 = true
			}
			yyh1780.ElemContainerState(yyj1780)
			if yyj1780 < len(yyv1780) {
				if r.TryDecodeAsNil() {
					yyv1780[yyj1780] = JobCondition{}
				} else {
					yyv1783 := &yyv1780[yyj1780]
					yyv1783.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1780 < len(yyv1780) {
			yyv1780 = yyv1780[:yyj1780]
			yyc1780 = true
		} else if yyj1780 == 0 && yyv1780 == nil {
			yyv1780 = []JobCondition{}
			yyc1780 = true
		}
	}
	yyh1780.End()
	if yyc1780 {
		*v = yyv1780
	}
}

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 _, yyv1784 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1785 := &yyv1784
		yy1785.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1786 := *v
	yyh1786, yyl1786 := z.DecSliceHelperStart()
	var yyc1786 bool
	if yyl1786 == 0 {
		if yyv1786 == nil {
			yyv1786 = []Ingress{}
			yyc1786 = true
		} else if len(yyv1786) != 0 {
			yyv1786 = yyv1786[:0]
			yyc1786 = true
		}
	} else if yyl1786 > 0 {
		var yyrr1786, yyrl1786 int
		var yyrt1786 bool
		if yyl1786 > cap(yyv1786) {

			yyrg1786 := len(yyv1786) > 0
			yyv21786 := yyv1786
			yyrl1786, yyrt1786 = z.DecInferLen(yyl1786, z.DecBasicHandle().MaxInitLen, 336)
			if yyrt1786 {
				if yyrl1786 <= cap(yyv1786) {
					yyv1786 = yyv1786[:yyrl1786]
				} else {
					yyv1786 = make([]Ingress, yyrl1786)
				}
			} else {
				yyv1786 = make([]Ingress, yyrl1786)
			}
			yyc1786 = true
			yyrr1786 = len(yyv1786)
			if yyrg1786 {
				copy(yyv1786, yyv21786)
			}
		} else if yyl1786 != len(yyv1786) {
			yyv1786 = yyv1786[:yyl1786]
			yyc1786 = true
		}
		yyj1786 := 0
		for ; yyj1786 < yyrr1786; yyj1786++ {
			yyh1786.ElemContainerState(yyj1786)
			if r.TryDecodeAsNil() {
				yyv1786[yyj1786] = Ingress{}
			} else {
				yyv1787 := &yyv1786[yyj1786]
				yyv1787.CodecDecodeSelf(d)
			}

		}
		if yyrt1786 {
			for ; yyj1786 < yyl1786; yyj1786++ {
				yyv1786 = append(yyv1786, Ingress{})
				yyh1786.ElemContainerState(yyj1786)
				if r.TryDecodeAsNil() {
					yyv1786[yyj1786] = Ingress{}
				} else {
					yyv1788 := &yyv1786[yyj1786]
					yyv1788.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1786 := 0
		for ; !r.CheckBreak(); yyj1786++ {

			if yyj1786 >= len(yyv1786) {
				yyv1786 = append(yyv1786, Ingress{}) // var yyz1786 Ingress
				yyc1786 = true
			}
			yyh1786.ElemContainerState(yyj1786)
			if yyj1786 < len(yyv1786) {
				if r.TryDecodeAsNil() {
					yyv1786[yyj1786] = Ingress{}
				} else {
					yyv1789 := &yyv1786[yyj1786]
					yyv1789.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1786 < len(yyv1786) {
			yyv1786 = yyv1786[:yyj1786]
			yyc1786 = true
		} else if yyj1786 == 0 && yyv1786 == nil {
			yyv1786 = []Ingress{}
			yyc1786 = true
		}
	}
	yyh1786.End()
	if yyc1786 {
		*v = yyv1786
	}
}

func (x codecSelfer1234) encSliceIngressTLS(v []IngressTLS, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1790 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1791 := &yyv1790
		yy1791.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1792 := *v
	yyh1792, yyl1792 := z.DecSliceHelperStart()
	var yyc1792 bool
	if yyl1792 == 0 {
		if yyv1792 == nil {
			yyv1792 = []IngressTLS{}
			yyc1792 = true
		} else if len(yyv1792) != 0 {
			yyv1792 = yyv1792[:0]
			yyc1792 = true
		}
	} else if yyl1792 > 0 {
		var yyrr1792, yyrl1792 int
		var yyrt1792 bool
		if yyl1792 > cap(yyv1792) {

			yyrg1792 := len(yyv1792) > 0
			yyv21792 := yyv1792
			yyrl1792, yyrt1792 = z.DecInferLen(yyl1792, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1792 {
				if yyrl1792 <= cap(yyv1792) {
					yyv1792 = yyv1792[:yyrl1792]
				} else {
					yyv1792 = make([]IngressTLS, yyrl1792)
				}
			} else {
				yyv1792 = make([]IngressTLS, yyrl1792)
			}
			yyc1792 = true
			yyrr1792 = len(yyv1792)
			if yyrg1792 {
				copy(yyv1792, yyv21792)
			}
		} else if yyl1792 != len(yyv1792) {
			yyv1792 = yyv1792[:yyl1792]
			yyc1792 = true
		}
		yyj1792 := 0
		for ; yyj1792 < yyrr1792; yyj1792++ {
			yyh1792.ElemContainerState(yyj1792)
			if r.TryDecodeAsNil() {
				yyv1792[yyj1792] = IngressTLS{}
			} else {
				yyv1793 := &yyv1792[yyj1792]
				yyv1793.CodecDecodeSelf(d)
			}

		}
		if yyrt1792 {
			for ; yyj1792 < yyl1792; yyj1792++ {
				yyv1792 = append(yyv1792, IngressTLS{})
				yyh1792.ElemContainerState(yyj1792)
				if r.TryDecodeAsNil() {
					yyv1792[yyj1792] = IngressTLS{}
				} else {
					yyv1794 := &yyv1792[yyj1792]
					yyv1794.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1792 := 0
		for ; !r.CheckBreak(); yyj1792++ {

			if yyj1792 >= len(yyv1792) {
				yyv1792 = append(yyv1792, IngressTLS{}) // var yyz1792 IngressTLS
				yyc1792 = true
			}
			yyh1792.ElemContainerState(yyj1792)
			if yyj1792 < len(yyv1792) {
				if r.TryDecodeAsNil() {
					yyv1792[yyj1792] = IngressTLS{}
				} else {
					yyv1795 := &yyv1792[yyj1792]
					yyv1795.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1792 < len(yyv1792) {
			yyv1792 = yyv1792[:yyj1792]
			yyc1792 = true
		} else if yyj1792 == 0 && yyv1792 == nil {
			yyv1792 = []IngressTLS{}
			yyc1792 = true
		}
	}
	yyh1792.End()
	if yyc1792 {
		*v = yyv1792
	}
}

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 _, yyv1796 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1797 := &yyv1796
		yy1797.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1798 := *v
	yyh1798, yyl1798 := z.DecSliceHelperStart()
	var yyc1798 bool
	if yyl1798 == 0 {
		if yyv1798 == nil {
			yyv1798 = []IngressRule{}
			yyc1798 = true
		} else if len(yyv1798) != 0 {
			yyv1798 = yyv1798[:0]
			yyc1798 = true
		}
	} else if yyl1798 > 0 {
		var yyrr1798, yyrl1798 int
		var yyrt1798 bool
		if yyl1798 > cap(yyv1798) {

			yyrg1798 := len(yyv1798) > 0
			yyv21798 := yyv1798
			yyrl1798, yyrt1798 = z.DecInferLen(yyl1798, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1798 {
				if yyrl1798 <= cap(yyv1798) {
					yyv1798 = yyv1798[:yyrl1798]
				} else {
					yyv1798 = make([]IngressRule, yyrl1798)
				}
			} else {
				yyv1798 = make([]IngressRule, yyrl1798)
			}
			yyc1798 = true
			yyrr1798 = len(yyv1798)
			if yyrg1798 {
				copy(yyv1798, yyv21798)
			}
		} else if yyl1798 != len(yyv1798) {
			yyv1798 = yyv1798[:yyl1798]
			yyc1798 = true
		}
		yyj1798 := 0
		for ; yyj1798 < yyrr1798; yyj1798++ {
			yyh1798.ElemContainerState(yyj1798)
			if r.TryDecodeAsNil() {
				yyv1798[yyj1798] = IngressRule{}
			} else {
				yyv1799 := &yyv1798[yyj1798]
				yyv1799.CodecDecodeSelf(d)
			}

		}
		if yyrt1798 {
			for ; yyj1798 < yyl1798; yyj1798++ {
				yyv1798 = append(yyv1798, IngressRule{})
				yyh1798.ElemContainerState(yyj1798)
				if r.TryDecodeAsNil() {
					yyv1798[yyj1798] = IngressRule{}
				} else {
					yyv1800 := &yyv1798[yyj1798]
					yyv1800.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1798 := 0
		for ; !r.CheckBreak(); yyj1798++ {

			if yyj1798 >= len(yyv1798) {
				yyv1798 = append(yyv1798, IngressRule{}) // var yyz1798 IngressRule
				yyc1798 = true
			}
			yyh1798.ElemContainerState(yyj1798)
			if yyj1798 < len(yyv1798) {
				if r.TryDecodeAsNil() {
					yyv1798[yyj1798] = IngressRule{}
				} else {
					yyv1801 := &yyv1798[yyj1798]
					yyv1801.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1798 < len(yyv1798) {
			yyv1798 = yyv1798[:yyj1798]
			yyc1798 = true
		} else if yyj1798 == 0 && yyv1798 == nil {
			yyv1798 = []IngressRule{}
			yyc1798 = true
		}
	}
	yyh1798.End()
	if yyc1798 {
		*v = yyv1798
	}
}

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 _, yyv1802 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1803 := &yyv1802
		yy1803.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1804 := *v
	yyh1804, yyl1804 := z.DecSliceHelperStart()
	var yyc1804 bool
	if yyl1804 == 0 {
		if yyv1804 == nil {
			yyv1804 = []HTTPIngressPath{}
			yyc1804 = true
		} else if len(yyv1804) != 0 {
			yyv1804 = yyv1804[:0]
			yyc1804 = true
		}
	} else if yyl1804 > 0 {
		var yyrr1804, yyrl1804 int
		var yyrt1804 bool
		if yyl1804 > cap(yyv1804) {

			yyrg1804 := len(yyv1804) > 0
			yyv21804 := yyv1804
			yyrl1804, yyrt1804 = z.DecInferLen(yyl1804, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1804 {
				if yyrl1804 <= cap(yyv1804) {
					yyv1804 = yyv1804[:yyrl1804]
				} else {
					yyv1804 = make([]HTTPIngressPath, yyrl1804)
				}
			} else {
				yyv1804 = make([]HTTPIngressPath, yyrl1804)
			}
			yyc1804 = true
			yyrr1804 = len(yyv1804)
			if yyrg1804 {
				copy(yyv1804, yyv21804)
			}
		} else if yyl1804 != len(yyv1804) {
			yyv1804 = yyv1804[:yyl1804]
			yyc1804 = true
		}
		yyj1804 := 0
		for ; yyj1804 < yyrr1804; yyj1804++ {
			yyh1804.ElemContainerState(yyj1804)
			if r.TryDecodeAsNil() {
				yyv1804[yyj1804] = HTTPIngressPath{}
			} else {
				yyv1805 := &yyv1804[yyj1804]
				yyv1805.CodecDecodeSelf(d)
			}

		}
		if yyrt1804 {
			for ; yyj1804 < yyl1804; yyj1804++ {
				yyv1804 = append(yyv1804, HTTPIngressPath{})
				yyh1804.ElemContainerState(yyj1804)
				if r.TryDecodeAsNil() {
					yyv1804[yyj1804] = HTTPIngressPath{}
				} else {
					yyv1806 := &yyv1804[yyj1804]
					yyv1806.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1804 := 0
		for ; !r.CheckBreak(); yyj1804++ {

			if yyj1804 >= len(yyv1804) {
				yyv1804 = append(yyv1804, HTTPIngressPath{}) // var yyz1804 HTTPIngressPath
				yyc1804 = true
			}
			yyh1804.ElemContainerState(yyj1804)
			if yyj1804 < len(yyv1804) {
				if r.TryDecodeAsNil() {
					yyv1804[yyj1804] = HTTPIngressPath{}
				} else {
					yyv1807 := &yyv1804[yyj1804]
					yyv1807.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1804 < len(yyv1804) {
			yyv1804 = yyv1804[:yyj1804]
			yyc1804 = true
		} else if yyj1804 == 0 && yyv1804 == nil {
			yyv1804 = []HTTPIngressPath{}
			yyc1804 = true
		}
	}
	yyh1804.End()
	if yyc1804 {
		*v = yyv1804
	}
}

func (x codecSelfer1234) encSliceLabelSelectorRequirement(v []LabelSelectorRequirement, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1808 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1809 := &yyv1808
		yy1809.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1810 := *v
	yyh1810, yyl1810 := z.DecSliceHelperStart()
	var yyc1810 bool
	if yyl1810 == 0 {
		if yyv1810 == nil {
			yyv1810 = []LabelSelectorRequirement{}
			yyc1810 = true
		} else if len(yyv1810) != 0 {
			yyv1810 = yyv1810[:0]
			yyc1810 = true
		}
	} else if yyl1810 > 0 {
		var yyrr1810, yyrl1810 int
		var yyrt1810 bool
		if yyl1810 > cap(yyv1810) {

			yyrg1810 := len(yyv1810) > 0
			yyv21810 := yyv1810
			yyrl1810, yyrt1810 = z.DecInferLen(yyl1810, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt1810 {
				if yyrl1810 <= cap(yyv1810) {
					yyv1810 = yyv1810[:yyrl1810]
				} else {
					yyv1810 = make([]LabelSelectorRequirement, yyrl1810)
				}
			} else {
				yyv1810 = make([]LabelSelectorRequirement, yyrl1810)
			}
			yyc1810 = true
			yyrr1810 = len(yyv1810)
			if yyrg1810 {
				copy(yyv1810, yyv21810)
			}
		} else if yyl1810 != len(yyv1810) {
			yyv1810 = yyv1810[:yyl1810]
			yyc1810 = true
		}
		yyj1810 := 0
		for ; yyj1810 < yyrr1810; yyj1810++ {
			yyh1810.ElemContainerState(yyj1810)
			if r.TryDecodeAsNil() {
				yyv1810[yyj1810] = LabelSelectorRequirement{}
			} else {
				yyv1811 := &yyv1810[yyj1810]
				yyv1811.CodecDecodeSelf(d)
			}

		}
		if yyrt1810 {
			for ; yyj1810 < yyl1810; yyj1810++ {
				yyv1810 = append(yyv1810, LabelSelectorRequirement{})
				yyh1810.ElemContainerState(yyj1810)
				if r.TryDecodeAsNil() {
					yyv1810[yyj1810] = LabelSelectorRequirement{}
				} else {
					yyv1812 := &yyv1810[yyj1810]
					yyv1812.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1810 := 0
		for ; !r.CheckBreak(); yyj1810++ {

			if yyj1810 >= len(yyv1810) {
				yyv1810 = append(yyv1810, LabelSelectorRequirement{}) // var yyz1810 LabelSelectorRequirement
				yyc1810 = true
			}
			yyh1810.ElemContainerState(yyj1810)
			if yyj1810 < len(yyv1810) {
				if r.TryDecodeAsNil() {
					yyv1810[yyj1810] = LabelSelectorRequirement{}
				} else {
					yyv1813 := &yyv1810[yyj1810]
					yyv1813.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1810 < len(yyv1810) {
			yyv1810 = yyv1810[:yyj1810]
			yyc1810 = true
		} else if yyj1810 == 0 && yyv1810 == nil {
			yyv1810 = []LabelSelectorRequirement{}
			yyc1810 = true
		}
	}
	yyh1810.End()
	if yyc1810 {
		*v = yyv1810
	}
}

func (x codecSelfer1234) encSliceReplicaSet(v []ReplicaSet, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1814 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1815 := &yyv1814
		yy1815.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1816 := *v
	yyh1816, yyl1816 := z.DecSliceHelperStart()
	var yyc1816 bool
	if yyl1816 == 0 {
		if yyv1816 == nil {
			yyv1816 = []ReplicaSet{}
			yyc1816 = true
		} else if len(yyv1816) != 0 {
			yyv1816 = yyv1816[:0]
			yyc1816 = true
		}
	} else if yyl1816 > 0 {
		var yyrr1816, yyrl1816 int
		var yyrt1816 bool
		if yyl1816 > cap(yyv1816) {

			yyrg1816 := len(yyv1816) > 0
			yyv21816 := yyv1816
			yyrl1816, yyrt1816 = z.DecInferLen(yyl1816, z.DecBasicHandle().MaxInitLen, 776)
			if yyrt1816 {
				if yyrl1816 <= cap(yyv1816) {
					yyv1816 = yyv1816[:yyrl1816]
				} else {
					yyv1816 = make([]ReplicaSet, yyrl1816)
				}
			} else {
				yyv1816 = make([]ReplicaSet, yyrl1816)
			}
			yyc1816 = true
			yyrr1816 = len(yyv1816)
			if yyrg1816 {
				copy(yyv1816, yyv21816)
			}
		} else if yyl1816 != len(yyv1816) {
			yyv1816 = yyv1816[:yyl1816]
			yyc1816 = true
		}
		yyj1816 := 0
		for ; yyj1816 < yyrr1816; yyj1816++ {
			yyh1816.ElemContainerState(yyj1816)
			if r.TryDecodeAsNil() {
				yyv1816[yyj1816] = ReplicaSet{}
			} else {
				yyv1817 := &yyv1816[yyj1816]
				yyv1817.CodecDecodeSelf(d)
			}

		}
		if yyrt1816 {
			for ; yyj1816 < yyl1816; yyj1816++ {
				yyv1816 = append(yyv1816, ReplicaSet{})
				yyh1816.ElemContainerState(yyj1816)
				if r.TryDecodeAsNil() {
					yyv1816[yyj1816] = ReplicaSet{}
				} else {
					yyv1818 := &yyv1816[yyj1816]
					yyv1818.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1816 := 0
		for ; !r.CheckBreak(); yyj1816++ {

			if yyj1816 >= len(yyv1816) {
				yyv1816 = append(yyv1816, ReplicaSet{}) // var yyz1816 ReplicaSet
				yyc1816 = true
			}
			yyh1816.ElemContainerState(yyj1816)
			if yyj1816 < len(yyv1816) {
				if r.TryDecodeAsNil() {
					yyv1816[yyj1816] = ReplicaSet{}
				} else {
					yyv1819 := &yyv1816[yyj1816]
					yyv1819.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1816 < len(yyv1816) {
			yyv1816 = yyv1816[:yyj1816]
			yyc1816 = true
		} else if yyj1816 == 0 && yyv1816 == nil {
			yyv1816 = []ReplicaSet{}
			yyc1816 = true
		}
	}
	yyh1816.End()
	if yyc1816 {
		*v = yyv1816
	}
}

func (x codecSelfer1234) encSlicev1_Capability(v []pkg2_v1.Capability, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1820 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yym1821 := z.EncBinary()
		_ = yym1821
		if false {
		} else if z.HasExtensions() && z.EncExt(yyv1820) {
		} else {
			r.EncodeString(codecSelferC_UTF81234, string(yyv1820))
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1822 := *v
	yyh1822, yyl1822 := z.DecSliceHelperStart()
	var yyc1822 bool
	if yyl1822 == 0 {
		if yyv1822 == nil {
			yyv1822 = []pkg2_v1.Capability{}
			yyc1822 = true
		} else if len(yyv1822) != 0 {
			yyv1822 = yyv1822[:0]
			yyc1822 = true
		}
	} else if yyl1822 > 0 {
		var yyrr1822, yyrl1822 int
		var yyrt1822 bool
		if yyl1822 > cap(yyv1822) {

			yyrl1822, yyrt1822 = z.DecInferLen(yyl1822, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1822 {
				if yyrl1822 <= cap(yyv1822) {
					yyv1822 = yyv1822[:yyrl1822]
				} else {
					yyv1822 = make([]pkg2_v1.Capability, yyrl1822)
				}
			} else {
				yyv1822 = make([]pkg2_v1.Capability, yyrl1822)
			}
			yyc1822 = true
			yyrr1822 = len(yyv1822)
		} else if yyl1822 != len(yyv1822) {
			yyv1822 = yyv1822[:yyl1822]
			yyc1822 = true
		}
		yyj1822 := 0
		for ; yyj1822 < yyrr1822; yyj1822++ {
			yyh1822.ElemContainerState(yyj1822)
			if r.TryDecodeAsNil() {
				yyv1822[yyj1822] = ""
			} else {
				yyv1822[yyj1822] = pkg2_v1.Capability(r.DecodeString())
			}

		}
		if yyrt1822 {
			for ; yyj1822 < yyl1822; yyj1822++ {
				yyv1822 = append(yyv1822, "")
				yyh1822.ElemContainerState(yyj1822)
				if r.TryDecodeAsNil() {
					yyv1822[yyj1822] = ""
				} else {
					yyv1822[yyj1822] = pkg2_v1.Capability(r.DecodeString())
				}

			}
		}

	} else {
		yyj1822 := 0
		for ; !r.CheckBreak(); yyj1822++ {

			if yyj1822 >= len(yyv1822) {
				yyv1822 = append(yyv1822, "") // var yyz1822 pkg2_v1.Capability
				yyc1822 = true
			}
			yyh1822.ElemContainerState(yyj1822)
			if yyj1822 < len(yyv1822) {
				if r.TryDecodeAsNil() {
					yyv1822[yyj1822] = ""
				} else {
					yyv1822[yyj1822] = pkg2_v1.Capability(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1822 < len(yyv1822) {
			yyv1822 = yyv1822[:yyj1822]
			yyc1822 = true
		} else if yyj1822 == 0 && yyv1822 == nil {
			yyv1822 = []pkg2_v1.Capability{}
			yyc1822 = true
		}
	}
	yyh1822.End()
	if yyc1822 {
		*v = yyv1822
	}
}

func (x codecSelfer1234) encSliceFSType(v []FSType, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1826 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yyv1826.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1827 := *v
	yyh1827, yyl1827 := z.DecSliceHelperStart()
	var yyc1827 bool
	if yyl1827 == 0 {
		if yyv1827 == nil {
			yyv1827 = []FSType{}
			yyc1827 = true
		} else if len(yyv1827) != 0 {
			yyv1827 = yyv1827[:0]
			yyc1827 = true
		}
	} else if yyl1827 > 0 {
		var yyrr1827, yyrl1827 int
		var yyrt1827 bool
		if yyl1827 > cap(yyv1827) {

			yyrl1827, yyrt1827 = z.DecInferLen(yyl1827, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1827 {
				if yyrl1827 <= cap(yyv1827) {
					yyv1827 = yyv1827[:yyrl1827]
				} else {
					yyv1827 = make([]FSType, yyrl1827)
				}
			} else {
				yyv1827 = make([]FSType, yyrl1827)
			}
			yyc1827 = true
			yyrr1827 = len(yyv1827)
		} else if yyl1827 != len(yyv1827) {
			yyv1827 = yyv1827[:yyl1827]
			yyc1827 = true
		}
		yyj1827 := 0
		for ; yyj1827 < yyrr1827; yyj1827++ {
			yyh1827.ElemContainerState(yyj1827)
			if r.TryDecodeAsNil() {
				yyv1827[yyj1827] = ""
			} else {
				yyv1827[yyj1827] = FSType(r.DecodeString())
			}

		}
		if yyrt1827 {
			for ; yyj1827 < yyl1827; yyj1827++ {
				yyv1827 = append(yyv1827, "")
				yyh1827.ElemContainerState(yyj1827)
				if r.TryDecodeAsNil() {
					yyv1827[yyj1827] = ""
				} else {
					yyv1827[yyj1827] = FSType(r.DecodeString())
				}

			}
		}

	} else {
		yyj1827 := 0
		for ; !r.CheckBreak(); yyj1827++ {

			if yyj1827 >= len(yyv1827) {
				yyv1827 = append(yyv1827, "") // var yyz1827 FSType
				yyc1827 = true
			}
			yyh1827.ElemContainerState(yyj1827)
			if yyj1827 < len(yyv1827) {
				if r.TryDecodeAsNil() {
					yyv1827[yyj1827] = ""
				} else {
					yyv1827[yyj1827] = FSType(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1827 < len(yyv1827) {
			yyv1827 = yyv1827[:yyj1827]
			yyc1827 = true
		} else if yyj1827 == 0 && yyv1827 == nil {
			yyv1827 = []FSType{}
			yyc1827 = true
		}
	}
	yyh1827.End()
	if yyc1827 {
		*v = yyv1827
	}
}

func (x codecSelfer1234) encSliceHostPortRange(v []HostPortRange, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1831 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1832 := &yyv1831
		yy1832.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1833 := *v
	yyh1833, yyl1833 := z.DecSliceHelperStart()
	var yyc1833 bool
	if yyl1833 == 0 {
		if yyv1833 == nil {
			yyv1833 = []HostPortRange{}
			yyc1833 = true
		} else if len(yyv1833) != 0 {
			yyv1833 = yyv1833[:0]
			yyc1833 = true
		}
	} else if yyl1833 > 0 {
		var yyrr1833, yyrl1833 int
		var yyrt1833 bool
		if yyl1833 > cap(yyv1833) {

			yyrg1833 := len(yyv1833) > 0
			yyv21833 := yyv1833
			yyrl1833, yyrt1833 = z.DecInferLen(yyl1833, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1833 {
				if yyrl1833 <= cap(yyv1833) {
					yyv1833 = yyv1833[:yyrl1833]
				} else {
					yyv1833 = make([]HostPortRange, yyrl1833)
				}
			} else {
				yyv1833 = make([]HostPortRange, yyrl1833)
			}
			yyc1833 = true
			yyrr1833 = len(yyv1833)
			if yyrg1833 {
				copy(yyv1833, yyv21833)
			}
		} else if yyl1833 != len(yyv1833) {
			yyv1833 = yyv1833[:yyl1833]
			yyc1833 = true
		}
		yyj1833 := 0
		for ; yyj1833 < yyrr1833; yyj1833++ {
			yyh1833.ElemContainerState(yyj1833)
			if r.TryDecodeAsNil() {
				yyv1833[yyj1833] = HostPortRange{}
			} else {
				yyv1834 := &yyv1833[yyj1833]
				yyv1834.CodecDecodeSelf(d)
			}

		}
		if yyrt1833 {
			for ; yyj1833 < yyl1833; yyj1833++ {
				yyv1833 = append(yyv1833, HostPortRange{})
				yyh1833.ElemContainerState(yyj1833)
				if r.TryDecodeAsNil() {
					yyv1833[yyj1833] = HostPortRange{}
				} else {
					yyv1835 := &yyv1833[yyj1833]
					yyv1835.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1833 := 0
		for ; !r.CheckBreak(); yyj1833++ {

			if yyj1833 >= len(yyv1833) {
				yyv1833 = append(yyv1833, HostPortRange{}) // var yyz1833 HostPortRange
				yyc1833 = true
			}
			yyh1833.ElemContainerState(yyj1833)
			if yyj1833 < len(yyv1833) {
				if r.TryDecodeAsNil() {
					yyv1833[yyj1833] = HostPortRange{}
				} else {
					yyv1836 := &yyv1833[yyj1833]
					yyv1836.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1833 < len(yyv1833) {
			yyv1833 = yyv1833[:yyj1833]
			yyc1833 = true
		} else if yyj1833 == 0 && yyv1833 == nil {
			yyv1833 = []HostPortRange{}
			yyc1833 = true
		}
	}
	yyh1833.End()
	if yyc1833 {
		*v = yyv1833
	}
}

func (x codecSelfer1234) encSliceIDRange(v []IDRange, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1837 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1838 := &yyv1837
		yy1838.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1839 := *v
	yyh1839, yyl1839 := z.DecSliceHelperStart()
	var yyc1839 bool
	if yyl1839 == 0 {
		if yyv1839 == nil {
			yyv1839 = []IDRange{}
			yyc1839 = true
		} else if len(yyv1839) != 0 {
			yyv1839 = yyv1839[:0]
			yyc1839 = true
		}
	} else if yyl1839 > 0 {
		var yyrr1839, yyrl1839 int
		var yyrt1839 bool
		if yyl1839 > cap(yyv1839) {

			yyrg1839 := len(yyv1839) > 0
			yyv21839 := yyv1839
			yyrl1839, yyrt1839 = z.DecInferLen(yyl1839, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1839 {
				if yyrl1839 <= cap(yyv1839) {
					yyv1839 = yyv1839[:yyrl1839]
				} else {
					yyv1839 = make([]IDRange, yyrl1839)
				}
			} else {
				yyv1839 = make([]IDRange, yyrl1839)
			}
			yyc1839 = true
			yyrr1839 = len(yyv1839)
			if yyrg1839 {
				copy(yyv1839, yyv21839)
			}
		} else if yyl1839 != len(yyv1839) {
			yyv1839 = yyv1839[:yyl1839]
			yyc1839 = true
		}
		yyj1839 := 0
		for ; yyj1839 < yyrr1839; yyj1839++ {
			yyh1839.ElemContainerState(yyj1839)
			if r.TryDecodeAsNil() {
				yyv1839[yyj1839] = IDRange{}
			} else {
				yyv1840 := &yyv1839[yyj1839]
				yyv1840.CodecDecodeSelf(d)
			}

		}
		if yyrt1839 {
			for ; yyj1839 < yyl1839; yyj1839++ {
				yyv1839 = append(yyv1839, IDRange{})
				yyh1839.ElemContainerState(yyj1839)
				if r.TryDecodeAsNil() {
					yyv1839[yyj1839] = IDRange{}
				} else {
					yyv1841 := &yyv1839[yyj1839]
					yyv1841.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1839 := 0
		for ; !r.CheckBreak(); yyj1839++ {

			if yyj1839 >= len(yyv1839) {
				yyv1839 = append(yyv1839, IDRange{}) // var yyz1839 IDRange
				yyc1839 = true
			}
			yyh1839.ElemContainerState(yyj1839)
			if yyj1839 < len(yyv1839) {
				if r.TryDecodeAsNil() {
					yyv1839[yyj1839] = IDRange{}
				} else {
					yyv1842 := &yyv1839[yyj1839]
					yyv1842.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1839 < len(yyv1839) {
			yyv1839 = yyv1839[:yyj1839]
			yyc1839 = true
		} else if yyj1839 == 0 && yyv1839 == nil {
			yyv1839 = []IDRange{}
			yyc1839 = true
		}
	}
	yyh1839.End()
	if yyc1839 {
		*v = yyv1839
	}
}

func (x codecSelfer1234) encSlicePodSecurityPolicy(v []PodSecurityPolicy, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1843 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1844 := &yyv1843
		yy1844.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1845 := *v
	yyh1845, yyl1845 := z.DecSliceHelperStart()
	var yyc1845 bool
	if yyl1845 == 0 {
		if yyv1845 == nil {
			yyv1845 = []PodSecurityPolicy{}
			yyc1845 = true
		} else if len(yyv1845) != 0 {
			yyv1845 = yyv1845[:0]
			yyc1845 = true
		}
	} else if yyl1845 > 0 {
		var yyrr1845, yyrl1845 int
		var yyrt1845 bool
		if yyl1845 > cap(yyv1845) {

			yyrg1845 := len(yyv1845) > 0
			yyv21845 := yyv1845
			yyrl1845, yyrt1845 = z.DecInferLen(yyl1845, z.DecBasicHandle().MaxInitLen, 552)
			if yyrt1845 {
				if yyrl1845 <= cap(yyv1845) {
					yyv1845 = yyv1845[:yyrl1845]
				} else {
					yyv1845 = make([]PodSecurityPolicy, yyrl1845)
				}
			} else {
				yyv1845 = make([]PodSecurityPolicy, yyrl1845)
			}
			yyc1845 = true
			yyrr1845 = len(yyv1845)
			if yyrg1845 {
				copy(yyv1845, yyv21845)
			}
		} else if yyl1845 != len(yyv1845) {
			yyv1845 = yyv1845[:yyl1845]
			yyc1845 = true
		}
		yyj1845 := 0
		for ; yyj1845 < yyrr1845; yyj1845++ {
			yyh1845.ElemContainerState(yyj1845)
			if r.TryDecodeAsNil() {
				yyv1845[yyj1845] = PodSecurityPolicy{}
			} else {
				yyv1846 := &yyv1845[yyj1845]
				yyv1846.CodecDecodeSelf(d)
			}

		}
		if yyrt1845 {
			for ; yyj1845 < yyl1845; yyj1845++ {
				yyv1845 = append(yyv1845, PodSecurityPolicy{})
				yyh1845.ElemContainerState(yyj1845)
				if r.TryDecodeAsNil() {
					yyv1845[yyj1845] = PodSecurityPolicy{}
				} else {
					yyv1847 := &yyv1845[yyj1845]
					yyv1847.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1845 := 0
		for ; !r.CheckBreak(); yyj1845++ {

			if yyj1845 >= len(yyv1845) {
				yyv1845 = append(yyv1845, PodSecurityPolicy{}) // var yyz1845 PodSecurityPolicy
				yyc1845 = true
			}
			yyh1845.ElemContainerState(yyj1845)
			if yyj1845 < len(yyv1845) {
				if r.TryDecodeAsNil() {
					yyv1845[yyj1845] = PodSecurityPolicy{}
				} else {
					yyv1848 := &yyv1845[yyj1845]
					yyv1848.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1845 < len(yyv1845) {
			yyv1845 = yyv1845[:yyj1845]
			yyc1845 = true
		} else if yyj1845 == 0 && yyv1845 == nil {
			yyv1845 = []PodSecurityPolicy{}
			yyc1845 = true
		}
	}
	yyh1845.End()
	if yyc1845 {
		*v = yyv1845
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyIngressRule(v []NetworkPolicyIngressRule, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1849 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1850 := &yyv1849
		yy1850.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1851 := *v
	yyh1851, yyl1851 := z.DecSliceHelperStart()
	var yyc1851 bool
	if yyl1851 == 0 {
		if yyv1851 == nil {
			yyv1851 = []NetworkPolicyIngressRule{}
			yyc1851 = true
		} else if len(yyv1851) != 0 {
			yyv1851 = yyv1851[:0]
			yyc1851 = true
		}
	} else if yyl1851 > 0 {
		var yyrr1851, yyrl1851 int
		var yyrt1851 bool
		if yyl1851 > cap(yyv1851) {

			yyrg1851 := len(yyv1851) > 0
			yyv21851 := yyv1851
			yyrl1851, yyrt1851 = z.DecInferLen(yyl1851, z.DecBasicHandle().MaxInitLen, 48)
			if yyrt1851 {
				if yyrl1851 <= cap(yyv1851) {
					yyv1851 = yyv1851[:yyrl1851]
				} else {
					yyv1851 = make([]NetworkPolicyIngressRule, yyrl1851)
				}
			} else {
				yyv1851 = make([]NetworkPolicyIngressRule, yyrl1851)
			}
			yyc1851 = true
			yyrr1851 = len(yyv1851)
			if yyrg1851 {
				copy(yyv1851, yyv21851)
			}
		} else if yyl1851 != len(yyv1851) {
			yyv1851 = yyv1851[:yyl1851]
			yyc1851 = true
		}
		yyj1851 := 0
		for ; yyj1851 < yyrr1851; yyj1851++ {
			yyh1851.ElemContainerState(yyj1851)
			if r.TryDecodeAsNil() {
				yyv1851[yyj1851] = NetworkPolicyIngressRule{}
			} else {
				yyv1852 := &yyv1851[yyj1851]
				yyv1852.CodecDecodeSelf(d)
			}

		}
		if yyrt1851 {
			for ; yyj1851 < yyl1851; yyj1851++ {
				yyv1851 = append(yyv1851, NetworkPolicyIngressRule{})
				yyh1851.ElemContainerState(yyj1851)
				if r.TryDecodeAsNil() {
					yyv1851[yyj1851] = NetworkPolicyIngressRule{}
				} else {
					yyv1853 := &yyv1851[yyj1851]
					yyv1853.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1851 := 0
		for ; !r.CheckBreak(); yyj1851++ {

			if yyj1851 >= len(yyv1851) {
				yyv1851 = append(yyv1851, NetworkPolicyIngressRule{}) // var yyz1851 NetworkPolicyIngressRule
				yyc1851 = true
			}
			yyh1851.ElemContainerState(yyj1851)
			if yyj1851 < len(yyv1851) {
				if r.TryDecodeAsNil() {
					yyv1851[yyj1851] = NetworkPolicyIngressRule{}
				} else {
					yyv1854 := &yyv1851[yyj1851]
					yyv1854.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1851 < len(yyv1851) {
			yyv1851 = yyv1851[:yyj1851]
			yyc1851 = true
		} else if yyj1851 == 0 && yyv1851 == nil {
			yyv1851 = []NetworkPolicyIngressRule{}
			yyc1851 = true
		}
	}
	yyh1851.End()
	if yyc1851 {
		*v = yyv1851
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyPort(v []NetworkPolicyPort, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1855 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1856 := &yyv1855
		yy1856.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1857 := *v
	yyh1857, yyl1857 := z.DecSliceHelperStart()
	var yyc1857 bool
	if yyl1857 == 0 {
		if yyv1857 == nil {
			yyv1857 = []NetworkPolicyPort{}
			yyc1857 = true
		} else if len(yyv1857) != 0 {
			yyv1857 = yyv1857[:0]
			yyc1857 = true
		}
	} else if yyl1857 > 0 {
		var yyrr1857, yyrl1857 int
		var yyrt1857 bool
		if yyl1857 > cap(yyv1857) {

			yyrg1857 := len(yyv1857) > 0
			yyv21857 := yyv1857
			yyrl1857, yyrt1857 = z.DecInferLen(yyl1857, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1857 {
				if yyrl1857 <= cap(yyv1857) {
					yyv1857 = yyv1857[:yyrl1857]
				} else {
					yyv1857 = make([]NetworkPolicyPort, yyrl1857)
				}
			} else {
				yyv1857 = make([]NetworkPolicyPort, yyrl1857)
			}
			yyc1857 = true
			yyrr1857 = len(yyv1857)
			if yyrg1857 {
				copy(yyv1857, yyv21857)
			}
		} else if yyl1857 != len(yyv1857) {
			yyv1857 = yyv1857[:yyl1857]
			yyc1857 = true
		}
		yyj1857 := 0
		for ; yyj1857 < yyrr1857; yyj1857++ {
			yyh1857.ElemContainerState(yyj1857)
			if r.TryDecodeAsNil() {
				yyv1857[yyj1857] = NetworkPolicyPort{}
			} else {
				yyv1858 := &yyv1857[yyj1857]
				yyv1858.CodecDecodeSelf(d)
			}

		}
		if yyrt1857 {
			for ; yyj1857 < yyl1857; yyj1857++ {
				yyv1857 = append(yyv1857, NetworkPolicyPort{})
				yyh1857.ElemContainerState(yyj1857)
				if r.TryDecodeAsNil() {
					yyv1857[yyj1857] = NetworkPolicyPort{}
				} else {
					yyv1859 := &yyv1857[yyj1857]
					yyv1859.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1857 := 0
		for ; !r.CheckBreak(); yyj1857++ {

			if yyj1857 >= len(yyv1857) {
				yyv1857 = append(yyv1857, NetworkPolicyPort{}) // var yyz1857 NetworkPolicyPort
				yyc1857 = true
			}
			yyh1857.ElemContainerState(yyj1857)
			if yyj1857 < len(yyv1857) {
				if r.TryDecodeAsNil() {
					yyv1857[yyj1857] = NetworkPolicyPort{}
				} else {
					yyv1860 := &yyv1857[yyj1857]
					yyv1860.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1857 < len(yyv1857) {
			yyv1857 = yyv1857[:yyj1857]
			yyc1857 = true
		} else if yyj1857 == 0 && yyv1857 == nil {
			yyv1857 = []NetworkPolicyPort{}
			yyc1857 = true
		}
	}
	yyh1857.End()
	if yyc1857 {
		*v = yyv1857
	}
}

func (x codecSelfer1234) encSliceNetworkPolicyPeer(v []NetworkPolicyPeer, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1861 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1862 := &yyv1861
		yy1862.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1863 := *v
	yyh1863, yyl1863 := z.DecSliceHelperStart()
	var yyc1863 bool
	if yyl1863 == 0 {
		if yyv1863 == nil {
			yyv1863 = []NetworkPolicyPeer{}
			yyc1863 = true
		} else if len(yyv1863) != 0 {
			yyv1863 = yyv1863[:0]
			yyc1863 = true
		}
	} else if yyl1863 > 0 {
		var yyrr1863, yyrl1863 int
		var yyrt1863 bool
		if yyl1863 > cap(yyv1863) {

			yyrg1863 := len(yyv1863) > 0
			yyv21863 := yyv1863
			yyrl1863, yyrt1863 = z.DecInferLen(yyl1863, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1863 {
				if yyrl1863 <= cap(yyv1863) {
					yyv1863 = yyv1863[:yyrl1863]
				} else {
					yyv1863 = make([]NetworkPolicyPeer, yyrl1863)
				}
			} else {
				yyv1863 = make([]NetworkPolicyPeer, yyrl1863)
			}
			yyc1863 = true
			yyrr1863 = len(yyv1863)
			if yyrg1863 {
				copy(yyv1863, yyv21863)
			}
		} else if yyl1863 != len(yyv1863) {
			yyv1863 = yyv1863[:yyl1863]
			yyc1863 = true
		}
		yyj1863 := 0
		for ; yyj1863 < yyrr1863; yyj1863++ {
			yyh1863.ElemContainerState(yyj1863)
			if r.TryDecodeAsNil() {
				yyv1863[yyj1863] = NetworkPolicyPeer{}
			} else {
				yyv1864 := &yyv1863[yyj1863]
				yyv1864.CodecDecodeSelf(d)
			}

		}
		if yyrt1863 {
			for ; yyj1863 < yyl1863; yyj1863++ {
				yyv1863 = append(yyv1863, NetworkPolicyPeer{})
				yyh1863.ElemContainerState(yyj1863)
				if r.TryDecodeAsNil() {
					yyv1863[yyj1863] = NetworkPolicyPeer{}
				} else {
					yyv1865 := &yyv1863[yyj1863]
					yyv1865.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1863 := 0
		for ; !r.CheckBreak(); yyj1863++ {

			if yyj1863 >= len(yyv1863) {
				yyv1863 = append(yyv1863, NetworkPolicyPeer{}) // var yyz1863 NetworkPolicyPeer
				yyc1863 = true
			}
			yyh1863.ElemContainerState(yyj1863)
			if yyj1863 < len(yyv1863) {
				if r.TryDecodeAsNil() {
					yyv1863[yyj1863] = NetworkPolicyPeer{}
				} else {
					yyv1866 := &yyv1863[yyj1863]
					yyv1866.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1863 < len(yyv1863) {
			yyv1863 = yyv1863[:yyj1863]
			yyc1863 = true
		} else if yyj1863 == 0 && yyv1863 == nil {
			yyv1863 = []NetworkPolicyPeer{}
			yyc1863 = true
		}
	}
	yyh1863.End()
	if yyc1863 {
		*v = yyv1863
	}
}

func (x codecSelfer1234) encSliceNetworkPolicy(v []NetworkPolicy, e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1867 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1868 := &yyv1867
		yy1868.CodecEncodeSelf(e)
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

	yyv1869 := *v
	yyh1869, yyl1869 := z.DecSliceHelperStart()
	var yyc1869 bool
	if yyl1869 == 0 {
		if yyv1869 == nil {
			yyv1869 = []NetworkPolicy{}
			yyc1869 = true
		} else if len(yyv1869) != 0 {
			yyv1869 = yyv1869[:0]
			yyc1869 = true
		}
	} else if yyl1869 > 0 {
		var yyrr1869, yyrl1869 int
		var yyrt1869 bool
		if yyl1869 > cap(yyv1869) {

			yyrg1869 := len(yyv1869) > 0
			yyv21869 := yyv1869
			yyrl1869, yyrt1869 = z.DecInferLen(yyl1869, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1869 {
				if yyrl1869 <= cap(yyv1869) {
					yyv1869 = yyv1869[:yyrl1869]
				} else {
					yyv1869 = make([]NetworkPolicy, yyrl1869)
				}
			} else {
				yyv1869 = make([]NetworkPolicy, yyrl1869)
			}
			yyc1869 = true
			yyrr1869 = len(yyv1869)
			if yyrg1869 {
				copy(yyv1869, yyv21869)
			}
		} else if yyl1869 != len(yyv1869) {
			yyv1869 = yyv1869[:yyl1869]
			yyc1869 = true
		}
		yyj1869 := 0
		for ; yyj1869 < yyrr1869; yyj1869++ {
			yyh1869.ElemContainerState(yyj1869)
			if r.TryDecodeAsNil() {
				yyv1869[yyj1869] = NetworkPolicy{}
			} else {
				yyv1870 := &yyv1869[yyj1869]
				yyv1870.CodecDecodeSelf(d)
			}

		}
		if yyrt1869 {
			for ; yyj1869 < yyl1869; yyj1869++ {
				yyv1869 = append(yyv1869, NetworkPolicy{})
				yyh1869.ElemContainerState(yyj1869)
				if r.TryDecodeAsNil() {
					yyv1869[yyj1869] = NetworkPolicy{}
				} else {
					yyv1871 := &yyv1869[yyj1869]
					yyv1871.CodecDecodeSelf(d)
				}

			}
		}

	} else {
		yyj1869 := 0
		for ; !r.CheckBreak(); yyj1869++ {

			if yyj1869 >= len(yyv1869) {
				yyv1869 = append(yyv1869, NetworkPolicy{}) // var yyz1869 NetworkPolicy
				yyc1869 = true
			}
			yyh1869.ElemContainerState(yyj1869)
			if yyj1869 < len(yyv1869) {
				if r.TryDecodeAsNil() {
					yyv1869[yyj1869] = NetworkPolicy{}
				} else {
					yyv1872 := &yyv1869[yyj1869]
					yyv1872.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1869 < len(yyv1869) {
			yyv1869 = yyv1869[:yyj1869]
			yyc1869 = true
		} else if yyj1869 == 0 && yyv1869 == nil {
			yyv1869 = []NetworkPolicy{}
			yyc1869 = true
		}
	}
	yyh1869.End()
	if yyc1869 {
		*v = yyv1869
	}
}