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/client-go/pkg/api/resource"
	pkg1_unversioned "k8s.io/client-go/pkg/api/unversioned"
	pkg2_v1 "k8s.io/client-go/pkg/api/v1"
	pkg3_types "k8s.io/client-go/pkg/types"
	pkg5_intstr "k8s.io/client-go/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 [4]bool
			_, _, _ = yysep658, yyq658, yy2arr658
			const yyr658 bool = false
			var yynn658 int
			if yyr658 || yy2arr658 {
				r.EncodeArrayStart(4)
			} else {
				yynn658 = 4
				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_containerArrayElem1234)
				yym669 := z.EncBinary()
				_ = yym669
				if false {
				} else {
					r.EncodeInt(int64(x.NumberReady))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberReady"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym670 := z.EncBinary()
				_ = yym670
				if false {
				} else {
					r.EncodeInt(int64(x.NumberReady))
				}
			}
			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
	yym671 := z.DecBinary()
	_ = yym671
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct672 := r.ContainerType()
		if yyct672 == codecSelferValueTypeMap1234 {
			yyl672 := r.ReadMapStart()
			if yyl672 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl672, d)
			}
		} else if yyct672 == codecSelferValueTypeArray1234 {
			yyl672 := r.ReadArrayStart()
			if yyl672 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl672, 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 yys673Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys673Slc
	var yyhl673 bool = l >= 0
	for yyj673 := 0; ; yyj673++ {
		if yyhl673 {
			if yyj673 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys673Slc = r.DecodeBytes(yys673Slc, true, true)
		yys673 := string(yys673Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys673 {
		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))
			}
		case "numberReady":
			if r.TryDecodeAsNil() {
				x.NumberReady = 0
			} else {
				x.NumberReady = int32(r.DecodeInt(32))
			}
		default:
			z.DecStructFieldNotFound(-1, yys673)
		} // end switch yys673
	} // end for yyj673
	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 yyj678 int
	var yyb678 bool
	var yyhl678 bool = l >= 0
	yyj678++
	if yyhl678 {
		yyb678 = yyj678 > l
	} else {
		yyb678 = r.CheckBreak()
	}
	if yyb678 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj678++
	if yyhl678 {
		yyb678 = yyj678 > l
	} else {
		yyb678 = r.CheckBreak()
	}
	if yyb678 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj678++
	if yyhl678 {
		yyb678 = yyj678 > l
	} else {
		yyb678 = r.CheckBreak()
	}
	if yyb678 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj678++
	if yyhl678 {
		yyb678 = yyj678 > l
	} else {
		yyb678 = r.CheckBreak()
	}
	if yyb678 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberReady = 0
	} else {
		x.NumberReady = int32(r.DecodeInt(32))
	}
	for {
		yyj678++
		if yyhl678 {
			yyb678 = yyj678 > l
		} else {
			yyb678 = r.CheckBreak()
		}
		if yyb678 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj678-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 {
		yym683 := z.EncBinary()
		_ = yym683
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep684 := !z.EncBinary()
			yy2arr684 := z.EncBasicHandle().StructToArray
			var yyq684 [5]bool
			_, _, _ = yysep684, yyq684, yy2arr684
			const yyr684 bool = false
			yyq684[0] = x.Kind != ""
			yyq684[1] = x.APIVersion != ""
			yyq684[2] = true
			yyq684[3] = true
			yyq684[4] = true
			var yynn684 int
			if yyr684 || yy2arr684 {
				r.EncodeArrayStart(5)
			} else {
				yynn684 = 0
				for _, b := range yyq684 {
					if b {
						yynn684++
					}
				}
				r.EncodeMapStart(yynn684)
				yynn684 = 0
			}
			if yyr684 || yy2arr684 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq684[0] {
					yym686 := z.EncBinary()
					_ = yym686
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq684[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym687 := z.EncBinary()
					_ = yym687
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr684 || yy2arr684 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq684[1] {
					yym689 := z.EncBinary()
					_ = yym689
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq684[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym690 := z.EncBinary()
					_ = yym690
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr684 || yy2arr684 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq684[2] {
					yy692 := &x.ObjectMeta
					yy692.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq684[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy693 := &x.ObjectMeta
					yy693.CodecEncodeSelf(e)
				}
			}
			if yyr684 || yy2arr684 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq684[3] {
					yy695 := &x.Spec
					yy695.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq684[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy696 := &x.Spec
					yy696.CodecEncodeSelf(e)
				}
			}
			if yyr684 || yy2arr684 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq684[4] {
					yy698 := &x.Status
					yy698.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq684[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy699 := &x.Status
					yy699.CodecEncodeSelf(e)
				}
			}
			if yyr684 || yy2arr684 {
				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
	yym700 := z.DecBinary()
	_ = yym700
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct701 := r.ContainerType()
		if yyct701 == codecSelferValueTypeMap1234 {
			yyl701 := r.ReadMapStart()
			if yyl701 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl701, d)
			}
		} else if yyct701 == codecSelferValueTypeArray1234 {
			yyl701 := r.ReadArrayStart()
			if yyl701 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl701, 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 yys702Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys702Slc
	var yyhl702 bool = l >= 0
	for yyj702 := 0; ; yyj702++ {
		if yyhl702 {
			if yyj702 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys702Slc = r.DecodeBytes(yys702Slc, true, true)
		yys702 := string(yys702Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys702 {
		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 {
				yyv705 := &x.ObjectMeta
				yyv705.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv706 := &x.Spec
				yyv706.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv707 := &x.Status
				yyv707.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys702)
		} // end switch yys702
	} // end for yyj702
	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 yyj708 int
	var yyb708 bool
	var yyhl708 bool = l >= 0
	yyj708++
	if yyhl708 {
		yyb708 = yyj708 > l
	} else {
		yyb708 = r.CheckBreak()
	}
	if yyb708 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj708++
	if yyhl708 {
		yyb708 = yyj708 > l
	} else {
		yyb708 = r.CheckBreak()
	}
	if yyb708 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj708++
	if yyhl708 {
		yyb708 = yyj708 > l
	} else {
		yyb708 = r.CheckBreak()
	}
	if yyb708 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv711 := &x.ObjectMeta
		yyv711.CodecDecodeSelf(d)
	}
	yyj708++
	if yyhl708 {
		yyb708 = yyj708 > l
	} else {
		yyb708 = r.CheckBreak()
	}
	if yyb708 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv712 := &x.Spec
		yyv712.CodecDecodeSelf(d)
	}
	yyj708++
	if yyhl708 {
		yyb708 = yyj708 > l
	} else {
		yyb708 = r.CheckBreak()
	}
	if yyb708 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv713 := &x.Status
		yyv713.CodecDecodeSelf(d)
	}
	for {
		yyj708++
		if yyhl708 {
			yyb708 = yyj708 > l
		} else {
			yyb708 = r.CheckBreak()
		}
		if yyb708 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj708-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 {
		yym714 := z.EncBinary()
		_ = yym714
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep715 := !z.EncBinary()
			yy2arr715 := z.EncBasicHandle().StructToArray
			var yyq715 [4]bool
			_, _, _ = yysep715, yyq715, yy2arr715
			const yyr715 bool = false
			yyq715[0] = x.Kind != ""
			yyq715[1] = x.APIVersion != ""
			yyq715[2] = true
			var yynn715 int
			if yyr715 || yy2arr715 {
				r.EncodeArrayStart(4)
			} else {
				yynn715 = 1
				for _, b := range yyq715 {
					if b {
						yynn715++
					}
				}
				r.EncodeMapStart(yynn715)
				yynn715 = 0
			}
			if yyr715 || yy2arr715 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq715[0] {
					yym717 := z.EncBinary()
					_ = yym717
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq715[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym718 := z.EncBinary()
					_ = yym718
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr715 || yy2arr715 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq715[1] {
					yym720 := z.EncBinary()
					_ = yym720
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq715[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym721 := z.EncBinary()
					_ = yym721
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr715 || yy2arr715 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq715[2] {
					yy723 := &x.ListMeta
					yym724 := z.EncBinary()
					_ = yym724
					if false {
					} else if z.HasExtensions() && z.EncExt(yy723) {
					} else {
						z.EncFallback(yy723)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq715[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy725 := &x.ListMeta
					yym726 := z.EncBinary()
					_ = yym726
					if false {
					} else if z.HasExtensions() && z.EncExt(yy725) {
					} else {
						z.EncFallback(yy725)
					}
				}
			}
			if yyr715 || yy2arr715 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym728 := z.EncBinary()
					_ = yym728
					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 {
					yym729 := z.EncBinary()
					_ = yym729
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr715 || yy2arr715 {
				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
	yym730 := z.DecBinary()
	_ = yym730
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct731 := r.ContainerType()
		if yyct731 == codecSelferValueTypeMap1234 {
			yyl731 := r.ReadMapStart()
			if yyl731 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl731, d)
			}
		} else if yyct731 == codecSelferValueTypeArray1234 {
			yyl731 := r.ReadArrayStart()
			if yyl731 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl731, 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 yys732Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys732Slc
	var yyhl732 bool = l >= 0
	for yyj732 := 0; ; yyj732++ {
		if yyhl732 {
			if yyj732 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys732Slc = r.DecodeBytes(yys732Slc, true, true)
		yys732 := string(yys732Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys732 {
		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 {
				yyv735 := &x.ListMeta
				yym736 := z.DecBinary()
				_ = yym736
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv735) {
				} else {
					z.DecFallback(yyv735, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv737 := &x.Items
				yym738 := z.DecBinary()
				_ = yym738
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv737), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys732)
		} // end switch yys732
	} // end for yyj732
	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 yyj739 int
	var yyb739 bool
	var yyhl739 bool = l >= 0
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv742 := &x.ListMeta
		yym743 := z.DecBinary()
		_ = yym743
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv742) {
		} else {
			z.DecFallback(yyv742, false)
		}
	}
	yyj739++
	if yyhl739 {
		yyb739 = yyj739 > l
	} else {
		yyb739 = r.CheckBreak()
	}
	if yyb739 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv744 := &x.Items
		yym745 := z.DecBinary()
		_ = yym745
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv744), d)
		}
	}
	for {
		yyj739++
		if yyhl739 {
			yyb739 = yyj739 > l
		} else {
			yyb739 = r.CheckBreak()
		}
		if yyb739 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj739-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 {
		yym746 := z.EncBinary()
		_ = yym746
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep747 := !z.EncBinary()
			yy2arr747 := z.EncBasicHandle().StructToArray
			var yyq747 [4]bool
			_, _, _ = yysep747, yyq747, yy2arr747
			const yyr747 bool = false
			yyq747[0] = x.Kind != ""
			yyq747[1] = x.APIVersion != ""
			yyq747[2] = true
			var yynn747 int
			if yyr747 || yy2arr747 {
				r.EncodeArrayStart(4)
			} else {
				yynn747 = 1
				for _, b := range yyq747 {
					if b {
						yynn747++
					}
				}
				r.EncodeMapStart(yynn747)
				yynn747 = 0
			}
			if yyr747 || yy2arr747 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq747[0] {
					yym749 := z.EncBinary()
					_ = yym749
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq747[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym750 := z.EncBinary()
					_ = yym750
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr747 || yy2arr747 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq747[1] {
					yym752 := z.EncBinary()
					_ = yym752
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq747[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym753 := z.EncBinary()
					_ = yym753
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr747 || yy2arr747 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq747[2] {
					yy755 := &x.ListMeta
					yym756 := z.EncBinary()
					_ = yym756
					if false {
					} else if z.HasExtensions() && z.EncExt(yy755) {
					} else {
						z.EncFallback(yy755)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq747[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy757 := &x.ListMeta
					yym758 := z.EncBinary()
					_ = yym758
					if false {
					} else if z.HasExtensions() && z.EncExt(yy757) {
					} else {
						z.EncFallback(yy757)
					}
				}
			}
			if yyr747 || yy2arr747 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym760 := z.EncBinary()
					_ = yym760
					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 {
					yym761 := z.EncBinary()
					_ = yym761
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr747 || yy2arr747 {
				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
	yym762 := z.DecBinary()
	_ = yym762
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct763 := r.ContainerType()
		if yyct763 == codecSelferValueTypeMap1234 {
			yyl763 := r.ReadMapStart()
			if yyl763 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl763, d)
			}
		} else if yyct763 == codecSelferValueTypeArray1234 {
			yyl763 := r.ReadArrayStart()
			if yyl763 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl763, 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 yys764Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys764Slc
	var yyhl764 bool = l >= 0
	for yyj764 := 0; ; yyj764++ {
		if yyhl764 {
			if yyj764 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys764Slc = r.DecodeBytes(yys764Slc, true, true)
		yys764 := string(yys764Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys764 {
		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 {
				yyv767 := &x.ListMeta
				yym768 := z.DecBinary()
				_ = yym768
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv767) {
				} else {
					z.DecFallback(yyv767, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv769 := &x.Items
				yym770 := z.DecBinary()
				_ = yym770
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv769), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys764)
		} // end switch yys764
	} // end for yyj764
	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 yyj771 int
	var yyb771 bool
	var yyhl771 bool = l >= 0
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv774 := &x.ListMeta
		yym775 := z.DecBinary()
		_ = yym775
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv774) {
		} else {
			z.DecFallback(yyv774, false)
		}
	}
	yyj771++
	if yyhl771 {
		yyb771 = yyj771 > l
	} else {
		yyb771 = r.CheckBreak()
	}
	if yyb771 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv776 := &x.Items
		yym777 := z.DecBinary()
		_ = yym777
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv776), d)
		}
	}
	for {
		yyj771++
		if yyhl771 {
			yyb771 = yyj771 > l
		} else {
			yyb771 = r.CheckBreak()
		}
		if yyb771 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj771-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 {
		yym778 := z.EncBinary()
		_ = yym778
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep779 := !z.EncBinary()
			yy2arr779 := z.EncBasicHandle().StructToArray
			var yyq779 [5]bool
			_, _, _ = yysep779, yyq779, yy2arr779
			const yyr779 bool = false
			yyq779[0] = x.Kind != ""
			yyq779[1] = x.APIVersion != ""
			yyq779[2] = true
			yyq779[3] = true
			yyq779[4] = true
			var yynn779 int
			if yyr779 || yy2arr779 {
				r.EncodeArrayStart(5)
			} else {
				yynn779 = 0
				for _, b := range yyq779 {
					if b {
						yynn779++
					}
				}
				r.EncodeMapStart(yynn779)
				yynn779 = 0
			}
			if yyr779 || yy2arr779 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq779[0] {
					yym781 := z.EncBinary()
					_ = yym781
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq779[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym782 := z.EncBinary()
					_ = yym782
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr779 || yy2arr779 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq779[1] {
					yym784 := z.EncBinary()
					_ = yym784
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq779[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym785 := z.EncBinary()
					_ = yym785
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr779 || yy2arr779 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq779[2] {
					yy787 := &x.ObjectMeta
					yy787.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq779[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy788 := &x.ObjectMeta
					yy788.CodecEncodeSelf(e)
				}
			}
			if yyr779 || yy2arr779 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq779[3] {
					yy790 := &x.Spec
					yy790.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq779[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy791 := &x.Spec
					yy791.CodecEncodeSelf(e)
				}
			}
			if yyr779 || yy2arr779 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq779[4] {
					yy793 := &x.Status
					yy793.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq779[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy794 := &x.Status
					yy794.CodecEncodeSelf(e)
				}
			}
			if yyr779 || yy2arr779 {
				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
	yym795 := z.DecBinary()
	_ = yym795
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct796 := r.ContainerType()
		if yyct796 == codecSelferValueTypeMap1234 {
			yyl796 := r.ReadMapStart()
			if yyl796 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl796, d)
			}
		} else if yyct796 == codecSelferValueTypeArray1234 {
			yyl796 := r.ReadArrayStart()
			if yyl796 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl796, 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 yys797Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys797Slc
	var yyhl797 bool = l >= 0
	for yyj797 := 0; ; yyj797++ {
		if yyhl797 {
			if yyj797 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys797Slc = r.DecodeBytes(yys797Slc, true, true)
		yys797 := string(yys797Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys797 {
		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 {
				yyv800 := &x.ObjectMeta
				yyv800.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = JobSpec{}
			} else {
				yyv801 := &x.Spec
				yyv801.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = JobStatus{}
			} else {
				yyv802 := &x.Status
				yyv802.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys797)
		} // end switch yys797
	} // end for yyj797
	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 yyj803 int
	var yyb803 bool
	var yyhl803 bool = l >= 0
	yyj803++
	if yyhl803 {
		yyb803 = yyj803 > l
	} else {
		yyb803 = r.CheckBreak()
	}
	if yyb803 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj803++
	if yyhl803 {
		yyb803 = yyj803 > l
	} else {
		yyb803 = r.CheckBreak()
	}
	if yyb803 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj803++
	if yyhl803 {
		yyb803 = yyj803 > l
	} else {
		yyb803 = r.CheckBreak()
	}
	if yyb803 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv806 := &x.ObjectMeta
		yyv806.CodecDecodeSelf(d)
	}
	yyj803++
	if yyhl803 {
		yyb803 = yyj803 > l
	} else {
		yyb803 = r.CheckBreak()
	}
	if yyb803 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = JobSpec{}
	} else {
		yyv807 := &x.Spec
		yyv807.CodecDecodeSelf(d)
	}
	yyj803++
	if yyhl803 {
		yyb803 = yyj803 > l
	} else {
		yyb803 = r.CheckBreak()
	}
	if yyb803 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = JobStatus{}
	} else {
		yyv808 := &x.Status
		yyv808.CodecDecodeSelf(d)
	}
	for {
		yyj803++
		if yyhl803 {
			yyb803 = yyj803 > l
		} else {
			yyb803 = r.CheckBreak()
		}
		if yyb803 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj803-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 {
		yym809 := z.EncBinary()
		_ = yym809
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep810 := !z.EncBinary()
			yy2arr810 := z.EncBasicHandle().StructToArray
			var yyq810 [4]bool
			_, _, _ = yysep810, yyq810, yy2arr810
			const yyr810 bool = false
			yyq810[0] = x.Kind != ""
			yyq810[1] = x.APIVersion != ""
			yyq810[2] = true
			var yynn810 int
			if yyr810 || yy2arr810 {
				r.EncodeArrayStart(4)
			} else {
				yynn810 = 1
				for _, b := range yyq810 {
					if b {
						yynn810++
					}
				}
				r.EncodeMapStart(yynn810)
				yynn810 = 0
			}
			if yyr810 || yy2arr810 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq810[0] {
					yym812 := z.EncBinary()
					_ = yym812
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq810[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym813 := z.EncBinary()
					_ = yym813
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr810 || yy2arr810 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq810[1] {
					yym815 := z.EncBinary()
					_ = yym815
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq810[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym816 := z.EncBinary()
					_ = yym816
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr810 || yy2arr810 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq810[2] {
					yy818 := &x.ListMeta
					yym819 := z.EncBinary()
					_ = yym819
					if false {
					} else if z.HasExtensions() && z.EncExt(yy818) {
					} else {
						z.EncFallback(yy818)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq810[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy820 := &x.ListMeta
					yym821 := z.EncBinary()
					_ = yym821
					if false {
					} else if z.HasExtensions() && z.EncExt(yy820) {
					} else {
						z.EncFallback(yy820)
					}
				}
			}
			if yyr810 || yy2arr810 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym823 := z.EncBinary()
					_ = yym823
					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 {
					yym824 := z.EncBinary()
					_ = yym824
					if false {
					} else {
						h.encSliceJob(([]Job)(x.Items), e)
					}
				}
			}
			if yyr810 || yy2arr810 {
				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
	yym825 := z.DecBinary()
	_ = yym825
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct826 := r.ContainerType()
		if yyct826 == codecSelferValueTypeMap1234 {
			yyl826 := r.ReadMapStart()
			if yyl826 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl826, d)
			}
		} else if yyct826 == codecSelferValueTypeArray1234 {
			yyl826 := r.ReadArrayStart()
			if yyl826 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl826, 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 yys827Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys827Slc
	var yyhl827 bool = l >= 0
	for yyj827 := 0; ; yyj827++ {
		if yyhl827 {
			if yyj827 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys827Slc = r.DecodeBytes(yys827Slc, true, true)
		yys827 := string(yys827Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys827 {
		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 {
				yyv830 := &x.ListMeta
				yym831 := z.DecBinary()
				_ = yym831
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv830) {
				} else {
					z.DecFallback(yyv830, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv832 := &x.Items
				yym833 := z.DecBinary()
				_ = yym833
				if false {
				} else {
					h.decSliceJob((*[]Job)(yyv832), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys827)
		} // end switch yys827
	} // end for yyj827
	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 yyj834 int
	var yyb834 bool
	var yyhl834 bool = l >= 0
	yyj834++
	if yyhl834 {
		yyb834 = yyj834 > l
	} else {
		yyb834 = r.CheckBreak()
	}
	if yyb834 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj834++
	if yyhl834 {
		yyb834 = yyj834 > l
	} else {
		yyb834 = r.CheckBreak()
	}
	if yyb834 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj834++
	if yyhl834 {
		yyb834 = yyj834 > l
	} else {
		yyb834 = r.CheckBreak()
	}
	if yyb834 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv837 := &x.ListMeta
		yym838 := z.DecBinary()
		_ = yym838
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv837) {
		} else {
			z.DecFallback(yyv837, false)
		}
	}
	yyj834++
	if yyhl834 {
		yyb834 = yyj834 > l
	} else {
		yyb834 = r.CheckBreak()
	}
	if yyb834 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv839 := &x.Items
		yym840 := z.DecBinary()
		_ = yym840
		if false {
		} else {
			h.decSliceJob((*[]Job)(yyv839), d)
		}
	}
	for {
		yyj834++
		if yyhl834 {
			yyb834 = yyj834 > l
		} else {
			yyb834 = r.CheckBreak()
		}
		if yyb834 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj834-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 {
		yym841 := z.EncBinary()
		_ = yym841
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep842 := !z.EncBinary()
			yy2arr842 := z.EncBasicHandle().StructToArray
			var yyq842 [6]bool
			_, _, _ = yysep842, yyq842, yy2arr842
			const yyr842 bool = false
			yyq842[0] = x.Parallelism != nil
			yyq842[1] = x.Completions != nil
			yyq842[2] = x.ActiveDeadlineSeconds != nil
			yyq842[3] = x.Selector != nil
			yyq842[4] = x.AutoSelector != nil
			var yynn842 int
			if yyr842 || yy2arr842 {
				r.EncodeArrayStart(6)
			} else {
				yynn842 = 1
				for _, b := range yyq842 {
					if b {
						yynn842++
					}
				}
				r.EncodeMapStart(yynn842)
				yynn842 = 0
			}
			if yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq842[0] {
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy844 := *x.Parallelism
						yym845 := z.EncBinary()
						_ = yym845
						if false {
						} else {
							r.EncodeInt(int64(yy844))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq842[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("parallelism"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Parallelism == nil {
						r.EncodeNil()
					} else {
						yy846 := *x.Parallelism
						yym847 := z.EncBinary()
						_ = yym847
						if false {
						} else {
							r.EncodeInt(int64(yy846))
						}
					}
				}
			}
			if yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq842[1] {
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy849 := *x.Completions
						yym850 := z.EncBinary()
						_ = yym850
						if false {
						} else {
							r.EncodeInt(int64(yy849))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq842[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Completions == nil {
						r.EncodeNil()
					} else {
						yy851 := *x.Completions
						yym852 := z.EncBinary()
						_ = yym852
						if false {
						} else {
							r.EncodeInt(int64(yy851))
						}
					}
				}
			}
			if yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq842[2] {
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy854 := *x.ActiveDeadlineSeconds
						yym855 := z.EncBinary()
						_ = yym855
						if false {
						} else {
							r.EncodeInt(int64(yy854))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq842[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("activeDeadlineSeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ActiveDeadlineSeconds == nil {
						r.EncodeNil()
					} else {
						yy856 := *x.ActiveDeadlineSeconds
						yym857 := z.EncBinary()
						_ = yym857
						if false {
						} else {
							r.EncodeInt(int64(yy856))
						}
					}
				}
			}
			if yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq842[3] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq842[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 yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq842[4] {
					if x.AutoSelector == nil {
						r.EncodeNil()
					} else {
						yy860 := *x.AutoSelector
						yym861 := z.EncBinary()
						_ = yym861
						if false {
						} else {
							r.EncodeBool(bool(yy860))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq842[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("autoSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AutoSelector == nil {
						r.EncodeNil()
					} else {
						yy862 := *x.AutoSelector
						yym863 := z.EncBinary()
						_ = yym863
						if false {
						} else {
							r.EncodeBool(bool(yy862))
						}
					}
				}
			}
			if yyr842 || yy2arr842 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy865 := &x.Template
				yy865.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy866 := &x.Template
				yy866.CodecEncodeSelf(e)
			}
			if yyr842 || yy2arr842 {
				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
	yym867 := z.DecBinary()
	_ = yym867
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct868 := r.ContainerType()
		if yyct868 == codecSelferValueTypeMap1234 {
			yyl868 := r.ReadMapStart()
			if yyl868 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl868, d)
			}
		} else if yyct868 == codecSelferValueTypeArray1234 {
			yyl868 := r.ReadArrayStart()
			if yyl868 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl868, 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 yys869Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys869Slc
	var yyhl869 bool = l >= 0
	for yyj869 := 0; ; yyj869++ {
		if yyhl869 {
			if yyj869 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys869Slc = r.DecodeBytes(yys869Slc, true, true)
		yys869 := string(yys869Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys869 {
		case "parallelism":
			if r.TryDecodeAsNil() {
				if x.Parallelism != nil {
					x.Parallelism = nil
				}
			} else {
				if x.Parallelism == nil {
					x.Parallelism = new(int32)
				}
				yym871 := z.DecBinary()
				_ = yym871
				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)
				}
				yym873 := z.DecBinary()
				_ = yym873
				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)
				}
				yym875 := z.DecBinary()
				_ = yym875
				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)
				}
				yym878 := z.DecBinary()
				_ = yym878
				if false {
				} else {
					*((*bool)(x.AutoSelector)) = r.DecodeBool()
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_v1.PodTemplateSpec{}
			} else {
				yyv879 := &x.Template
				yyv879.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys869)
		} // end switch yys869
	} // end for yyj869
	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 yyj880 int
	var yyb880 bool
	var yyhl880 bool = l >= 0
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		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)
		}
		yym882 := z.DecBinary()
		_ = yym882
		if false {
		} else {
			*((*int32)(x.Parallelism)) = int32(r.DecodeInt(32))
		}
	}
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		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)
		}
		yym884 := z.DecBinary()
		_ = yym884
		if false {
		} else {
			*((*int32)(x.Completions)) = int32(r.DecodeInt(32))
		}
	}
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		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)
		}
		yym886 := z.DecBinary()
		_ = yym886
		if false {
		} else {
			*((*int64)(x.ActiveDeadlineSeconds)) = int64(r.DecodeInt(64))
		}
	}
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		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)
	}
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		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)
		}
		yym889 := z.DecBinary()
		_ = yym889
		if false {
		} else {
			*((*bool)(x.AutoSelector)) = r.DecodeBool()
		}
	}
	yyj880++
	if yyhl880 {
		yyb880 = yyj880 > l
	} else {
		yyb880 = r.CheckBreak()
	}
	if yyb880 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv890 := &x.Template
		yyv890.CodecDecodeSelf(d)
	}
	for {
		yyj880++
		if yyhl880 {
			yyb880 = yyj880 > l
		} else {
			yyb880 = r.CheckBreak()
		}
		if yyb880 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj880-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 {
		yym891 := z.EncBinary()
		_ = yym891
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep892 := !z.EncBinary()
			yy2arr892 := z.EncBasicHandle().StructToArray
			var yyq892 [6]bool
			_, _, _ = yysep892, yyq892, yy2arr892
			const yyr892 bool = false
			yyq892[0] = len(x.Conditions) != 0
			yyq892[1] = x.StartTime != nil
			yyq892[2] = x.CompletionTime != nil
			yyq892[3] = x.Active != 0
			yyq892[4] = x.Succeeded != 0
			yyq892[5] = x.Failed != 0
			var yynn892 int
			if yyr892 || yy2arr892 {
				r.EncodeArrayStart(6)
			} else {
				yynn892 = 0
				for _, b := range yyq892 {
					if b {
						yynn892++
					}
				}
				r.EncodeMapStart(yynn892)
				yynn892 = 0
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[0] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym894 := z.EncBinary()
						_ = yym894
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq892[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym895 := z.EncBinary()
						_ = yym895
						if false {
						} else {
							h.encSliceJobCondition(([]JobCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[1] {
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym897 := z.EncBinary()
						_ = yym897
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym897 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym897 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq892[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("startTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.StartTime == nil {
						r.EncodeNil()
					} else {
						yym898 := z.EncBinary()
						_ = yym898
						if false {
						} else if z.HasExtensions() && z.EncExt(x.StartTime) {
						} else if yym898 {
							z.EncBinaryMarshal(x.StartTime)
						} else if !yym898 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.StartTime)
						} else {
							z.EncFallback(x.StartTime)
						}
					}
				}
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[2] {
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym900 := z.EncBinary()
						_ = yym900
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym900 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym900 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq892[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("completionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.CompletionTime == nil {
						r.EncodeNil()
					} else {
						yym901 := z.EncBinary()
						_ = yym901
						if false {
						} else if z.HasExtensions() && z.EncExt(x.CompletionTime) {
						} else if yym901 {
							z.EncBinaryMarshal(x.CompletionTime)
						} else if !yym901 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.CompletionTime)
						} else {
							z.EncFallback(x.CompletionTime)
						}
					}
				}
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[3] {
					yym903 := z.EncBinary()
					_ = yym903
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq892[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("active"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym904 := z.EncBinary()
					_ = yym904
					if false {
					} else {
						r.EncodeInt(int64(x.Active))
					}
				}
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[4] {
					yym906 := z.EncBinary()
					_ = yym906
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq892[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("succeeded"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym907 := z.EncBinary()
					_ = yym907
					if false {
					} else {
						r.EncodeInt(int64(x.Succeeded))
					}
				}
			}
			if yyr892 || yy2arr892 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq892[5] {
					yym909 := z.EncBinary()
					_ = yym909
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq892[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("failed"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym910 := z.EncBinary()
					_ = yym910
					if false {
					} else {
						r.EncodeInt(int64(x.Failed))
					}
				}
			}
			if yyr892 || yy2arr892 {
				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
	yym911 := z.DecBinary()
	_ = yym911
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct912 := r.ContainerType()
		if yyct912 == codecSelferValueTypeMap1234 {
			yyl912 := r.ReadMapStart()
			if yyl912 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl912, d)
			}
		} else if yyct912 == codecSelferValueTypeArray1234 {
			yyl912 := r.ReadArrayStart()
			if yyl912 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl912, 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 yys913Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys913Slc
	var yyhl913 bool = l >= 0
	for yyj913 := 0; ; yyj913++ {
		if yyhl913 {
			if yyj913 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys913Slc = r.DecodeBytes(yys913Slc, true, true)
		yys913 := string(yys913Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys913 {
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv914 := &x.Conditions
				yym915 := z.DecBinary()
				_ = yym915
				if false {
				} else {
					h.decSliceJobCondition((*[]JobCondition)(yyv914), d)
				}
			}
		case "startTime":
			if r.TryDecodeAsNil() {
				if x.StartTime != nil {
					x.StartTime = nil
				}
			} else {
				if x.StartTime == nil {
					x.StartTime = new(pkg1_unversioned.Time)
				}
				yym917 := z.DecBinary()
				_ = yym917
				if false {
				} else if z.HasExtensions() && z.DecExt(x.StartTime) {
				} else if yym917 {
					z.DecBinaryUnmarshal(x.StartTime)
				} else if !yym917 && 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)
				}
				yym919 := z.DecBinary()
				_ = yym919
				if false {
				} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
				} else if yym919 {
					z.DecBinaryUnmarshal(x.CompletionTime)
				} else if !yym919 && 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, yys913)
		} // end switch yys913
	} // end for yyj913
	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 yyj923 int
	var yyb923 bool
	var yyhl923 bool = l >= 0
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv924 := &x.Conditions
		yym925 := z.DecBinary()
		_ = yym925
		if false {
		} else {
			h.decSliceJobCondition((*[]JobCondition)(yyv924), d)
		}
	}
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		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)
		}
		yym927 := z.DecBinary()
		_ = yym927
		if false {
		} else if z.HasExtensions() && z.DecExt(x.StartTime) {
		} else if yym927 {
			z.DecBinaryUnmarshal(x.StartTime)
		} else if !yym927 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.StartTime)
		} else {
			z.DecFallback(x.StartTime, false)
		}
	}
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		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)
		}
		yym929 := z.DecBinary()
		_ = yym929
		if false {
		} else if z.HasExtensions() && z.DecExt(x.CompletionTime) {
		} else if yym929 {
			z.DecBinaryUnmarshal(x.CompletionTime)
		} else if !yym929 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.CompletionTime)
		} else {
			z.DecFallback(x.CompletionTime, false)
		}
	}
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Active = 0
	} else {
		x.Active = int32(r.DecodeInt(32))
	}
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Succeeded = 0
	} else {
		x.Succeeded = int32(r.DecodeInt(32))
	}
	yyj923++
	if yyhl923 {
		yyb923 = yyj923 > l
	} else {
		yyb923 = r.CheckBreak()
	}
	if yyb923 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Failed = 0
	} else {
		x.Failed = int32(r.DecodeInt(32))
	}
	for {
		yyj923++
		if yyhl923 {
			yyb923 = yyj923 > l
		} else {
			yyb923 = r.CheckBreak()
		}
		if yyb923 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj923-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x JobConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym933 := z.EncBinary()
	_ = yym933
	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
	yym934 := z.DecBinary()
	_ = yym934
	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 {
		yym935 := z.EncBinary()
		_ = yym935
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep936 := !z.EncBinary()
			yy2arr936 := z.EncBasicHandle().StructToArray
			var yyq936 [6]bool
			_, _, _ = yysep936, yyq936, yy2arr936
			const yyr936 bool = false
			yyq936[2] = true
			yyq936[3] = true
			yyq936[4] = x.Reason != ""
			yyq936[5] = x.Message != ""
			var yynn936 int
			if yyr936 || yy2arr936 {
				r.EncodeArrayStart(6)
			} else {
				yynn936 = 2
				for _, b := range yyq936 {
					if b {
						yynn936++
					}
				}
				r.EncodeMapStart(yynn936)
				yynn936 = 0
			}
			if yyr936 || yy2arr936 {
				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 yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym939 := z.EncBinary()
				_ = yym939
				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)
				yym940 := z.EncBinary()
				_ = yym940
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[2] {
					yy942 := &x.LastProbeTime
					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 yyq936[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy944 := &x.LastProbeTime
					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 yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[3] {
					yy947 := &x.LastTransitionTime
					yym948 := z.EncBinary()
					_ = yym948
					if false {
					} else if z.HasExtensions() && z.EncExt(yy947) {
					} else if yym948 {
						z.EncBinaryMarshal(yy947)
					} else if !yym948 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy947)
					} else {
						z.EncFallback(yy947)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq936[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy949 := &x.LastTransitionTime
					yym950 := z.EncBinary()
					_ = yym950
					if false {
					} else if z.HasExtensions() && z.EncExt(yy949) {
					} else if yym950 {
						z.EncBinaryMarshal(yy949)
					} else if !yym950 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy949)
					} else {
						z.EncFallback(yy949)
					}
				}
			}
			if yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[4] {
					yym952 := z.EncBinary()
					_ = yym952
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq936[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym953 := z.EncBinary()
					_ = yym953
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr936 || yy2arr936 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq936[5] {
					yym955 := z.EncBinary()
					_ = yym955
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq936[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym956 := z.EncBinary()
					_ = yym956
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr936 || yy2arr936 {
				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
	yym957 := z.DecBinary()
	_ = yym957
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct958 := r.ContainerType()
		if yyct958 == codecSelferValueTypeMap1234 {
			yyl958 := r.ReadMapStart()
			if yyl958 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl958, d)
			}
		} else if yyct958 == codecSelferValueTypeArray1234 {
			yyl958 := r.ReadArrayStart()
			if yyl958 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl958, 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 yys959Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys959Slc
	var yyhl959 bool = l >= 0
	for yyj959 := 0; ; yyj959++ {
		if yyhl959 {
			if yyj959 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys959Slc = r.DecodeBytes(yys959Slc, true, true)
		yys959 := string(yys959Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys959 {
		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 {
				yyv962 := &x.LastProbeTime
				yym963 := z.DecBinary()
				_ = yym963
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv962) {
				} else if yym963 {
					z.DecBinaryUnmarshal(yyv962)
				} else if !yym963 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv962)
				} else {
					z.DecFallback(yyv962, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv964 := &x.LastTransitionTime
				yym965 := z.DecBinary()
				_ = yym965
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv964) {
				} else if yym965 {
					z.DecBinaryUnmarshal(yyv964)
				} else if !yym965 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv964)
				} else {
					z.DecFallback(yyv964, 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, yys959)
		} // end switch yys959
	} // end for yyj959
	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 yyj968 int
	var yyb968 bool
	var yyhl968 bool = l >= 0
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = JobConditionType(r.DecodeString())
	}
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv971 := &x.LastProbeTime
		yym972 := z.DecBinary()
		_ = yym972
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv971) {
		} else if yym972 {
			z.DecBinaryUnmarshal(yyv971)
		} else if !yym972 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv971)
		} else {
			z.DecFallback(yyv971, false)
		}
	}
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv973 := &x.LastTransitionTime
		yym974 := z.DecBinary()
		_ = yym974
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv973) {
		} else if yym974 {
			z.DecBinaryUnmarshal(yyv973)
		} else if !yym974 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv973)
		} else {
			z.DecFallback(yyv973, false)
		}
	}
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj968++
	if yyhl968 {
		yyb968 = yyj968 > l
	} else {
		yyb968 = r.CheckBreak()
	}
	if yyb968 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj968++
		if yyhl968 {
			yyb968 = yyj968 > l
		} else {
			yyb968 = r.CheckBreak()
		}
		if yyb968 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj968-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 {
		yym977 := z.EncBinary()
		_ = yym977
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep978 := !z.EncBinary()
			yy2arr978 := z.EncBasicHandle().StructToArray
			var yyq978 [5]bool
			_, _, _ = yysep978, yyq978, yy2arr978
			const yyr978 bool = false
			yyq978[0] = x.Kind != ""
			yyq978[1] = x.APIVersion != ""
			yyq978[2] = true
			yyq978[3] = true
			yyq978[4] = true
			var yynn978 int
			if yyr978 || yy2arr978 {
				r.EncodeArrayStart(5)
			} else {
				yynn978 = 0
				for _, b := range yyq978 {
					if b {
						yynn978++
					}
				}
				r.EncodeMapStart(yynn978)
				yynn978 = 0
			}
			if yyr978 || yy2arr978 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq978[0] {
					yym980 := z.EncBinary()
					_ = yym980
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq978[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym981 := z.EncBinary()
					_ = yym981
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr978 || yy2arr978 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq978[1] {
					yym983 := z.EncBinary()
					_ = yym983
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq978[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym984 := z.EncBinary()
					_ = yym984
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr978 || yy2arr978 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq978[2] {
					yy986 := &x.ObjectMeta
					yy986.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq978[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy987 := &x.ObjectMeta
					yy987.CodecEncodeSelf(e)
				}
			}
			if yyr978 || yy2arr978 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq978[3] {
					yy989 := &x.Spec
					yy989.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq978[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy990 := &x.Spec
					yy990.CodecEncodeSelf(e)
				}
			}
			if yyr978 || yy2arr978 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq978[4] {
					yy992 := &x.Status
					yy992.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq978[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy993 := &x.Status
					yy993.CodecEncodeSelf(e)
				}
			}
			if yyr978 || yy2arr978 {
				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
	yym994 := z.DecBinary()
	_ = yym994
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct995 := r.ContainerType()
		if yyct995 == codecSelferValueTypeMap1234 {
			yyl995 := r.ReadMapStart()
			if yyl995 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl995, d)
			}
		} else if yyct995 == codecSelferValueTypeArray1234 {
			yyl995 := r.ReadArrayStart()
			if yyl995 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl995, 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 yys996Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys996Slc
	var yyhl996 bool = l >= 0
	for yyj996 := 0; ; yyj996++ {
		if yyhl996 {
			if yyj996 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys996Slc = r.DecodeBytes(yys996Slc, true, true)
		yys996 := string(yys996Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys996 {
		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 {
				yyv999 := &x.ObjectMeta
				yyv999.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv1000 := &x.Spec
				yyv1000.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv1001 := &x.Status
				yyv1001.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys996)
		} // end switch yys996
	} // end for yyj996
	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 yyj1002 int
	var yyb1002 bool
	var yyhl1002 bool = l >= 0
	yyj1002++
	if yyhl1002 {
		yyb1002 = yyj1002 > l
	} else {
		yyb1002 = r.CheckBreak()
	}
	if yyb1002 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1002++
	if yyhl1002 {
		yyb1002 = yyj1002 > l
	} else {
		yyb1002 = r.CheckBreak()
	}
	if yyb1002 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1002++
	if yyhl1002 {
		yyb1002 = yyj1002 > l
	} else {
		yyb1002 = r.CheckBreak()
	}
	if yyb1002 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1005 := &x.ObjectMeta
		yyv1005.CodecDecodeSelf(d)
	}
	yyj1002++
	if yyhl1002 {
		yyb1002 = yyj1002 > l
	} else {
		yyb1002 = r.CheckBreak()
	}
	if yyb1002 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv1006 := &x.Spec
		yyv1006.CodecDecodeSelf(d)
	}
	yyj1002++
	if yyhl1002 {
		yyb1002 = yyj1002 > l
	} else {
		yyb1002 = r.CheckBreak()
	}
	if yyb1002 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv1007 := &x.Status
		yyv1007.CodecDecodeSelf(d)
	}
	for {
		yyj1002++
		if yyhl1002 {
			yyb1002 = yyj1002 > l
		} else {
			yyb1002 = r.CheckBreak()
		}
		if yyb1002 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1002-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 {
		yym1008 := z.EncBinary()
		_ = yym1008
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1009 := !z.EncBinary()
			yy2arr1009 := z.EncBasicHandle().StructToArray
			var yyq1009 [4]bool
			_, _, _ = yysep1009, yyq1009, yy2arr1009
			const yyr1009 bool = false
			yyq1009[0] = x.Kind != ""
			yyq1009[1] = x.APIVersion != ""
			yyq1009[2] = true
			var yynn1009 int
			if yyr1009 || yy2arr1009 {
				r.EncodeArrayStart(4)
			} else {
				yynn1009 = 1
				for _, b := range yyq1009 {
					if b {
						yynn1009++
					}
				}
				r.EncodeMapStart(yynn1009)
				yynn1009 = 0
			}
			if yyr1009 || yy2arr1009 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1009[0] {
					yym1011 := z.EncBinary()
					_ = yym1011
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1009[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1012 := z.EncBinary()
					_ = yym1012
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1009 || yy2arr1009 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1009[1] {
					yym1014 := z.EncBinary()
					_ = yym1014
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1009[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1015 := z.EncBinary()
					_ = yym1015
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1009 || yy2arr1009 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1009[2] {
					yy1017 := &x.ListMeta
					yym1018 := z.EncBinary()
					_ = yym1018
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1017) {
					} else {
						z.EncFallback(yy1017)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1009[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1019 := &x.ListMeta
					yym1020 := z.EncBinary()
					_ = yym1020
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1019) {
					} else {
						z.EncFallback(yy1019)
					}
				}
			}
			if yyr1009 || yy2arr1009 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1022 := z.EncBinary()
					_ = yym1022
					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 {
					yym1023 := z.EncBinary()
					_ = yym1023
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr1009 || yy2arr1009 {
				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
	yym1024 := z.DecBinary()
	_ = yym1024
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1025 := r.ContainerType()
		if yyct1025 == codecSelferValueTypeMap1234 {
			yyl1025 := r.ReadMapStart()
			if yyl1025 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1025, d)
			}
		} else if yyct1025 == codecSelferValueTypeArray1234 {
			yyl1025 := r.ReadArrayStart()
			if yyl1025 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1025, 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 yys1026Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1026Slc
	var yyhl1026 bool = l >= 0
	for yyj1026 := 0; ; yyj1026++ {
		if yyhl1026 {
			if yyj1026 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1026Slc = r.DecodeBytes(yys1026Slc, true, true)
		yys1026 := string(yys1026Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1026 {
		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 {
				yyv1029 := &x.ListMeta
				yym1030 := z.DecBinary()
				_ = yym1030
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1029) {
				} else {
					z.DecFallback(yyv1029, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1031 := &x.Items
				yym1032 := z.DecBinary()
				_ = yym1032
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv1031), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1026)
		} // end switch yys1026
	} // end for yyj1026
	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 yyj1033 int
	var yyb1033 bool
	var yyhl1033 bool = l >= 0
	yyj1033++
	if yyhl1033 {
		yyb1033 = yyj1033 > l
	} else {
		yyb1033 = r.CheckBreak()
	}
	if yyb1033 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1033++
	if yyhl1033 {
		yyb1033 = yyj1033 > l
	} else {
		yyb1033 = r.CheckBreak()
	}
	if yyb1033 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1033++
	if yyhl1033 {
		yyb1033 = yyj1033 > l
	} else {
		yyb1033 = r.CheckBreak()
	}
	if yyb1033 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1036 := &x.ListMeta
		yym1037 := z.DecBinary()
		_ = yym1037
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1036) {
		} else {
			z.DecFallback(yyv1036, false)
		}
	}
	yyj1033++
	if yyhl1033 {
		yyb1033 = yyj1033 > l
	} else {
		yyb1033 = r.CheckBreak()
	}
	if yyb1033 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1038 := &x.Items
		yym1039 := z.DecBinary()
		_ = yym1039
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv1038), d)
		}
	}
	for {
		yyj1033++
		if yyhl1033 {
			yyb1033 = yyj1033 > l
		} else {
			yyb1033 = r.CheckBreak()
		}
		if yyb1033 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1033-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 {
		yym1040 := z.EncBinary()
		_ = yym1040
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1041 := !z.EncBinary()
			yy2arr1041 := z.EncBasicHandle().StructToArray
			var yyq1041 [3]bool
			_, _, _ = yysep1041, yyq1041, yy2arr1041
			const yyr1041 bool = false
			yyq1041[0] = x.Backend != nil
			yyq1041[1] = len(x.TLS) != 0
			yyq1041[2] = len(x.Rules) != 0
			var yynn1041 int
			if yyr1041 || yy2arr1041 {
				r.EncodeArrayStart(3)
			} else {
				yynn1041 = 0
				for _, b := range yyq1041 {
					if b {
						yynn1041++
					}
				}
				r.EncodeMapStart(yynn1041)
				yynn1041 = 0
			}
			if yyr1041 || yy2arr1041 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1041[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1041[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 yyr1041 || yy2arr1041 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1041[1] {
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1044 := z.EncBinary()
						_ = yym1044
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1041[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("tls"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym1045 := z.EncBinary()
						_ = yym1045
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				}
			}
			if yyr1041 || yy2arr1041 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1041[2] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1047 := z.EncBinary()
						_ = yym1047
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1041[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym1048 := z.EncBinary()
						_ = yym1048
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr1041 || yy2arr1041 {
				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
	yym1049 := z.DecBinary()
	_ = yym1049
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1050 := r.ContainerType()
		if yyct1050 == codecSelferValueTypeMap1234 {
			yyl1050 := r.ReadMapStart()
			if yyl1050 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1050, d)
			}
		} else if yyct1050 == codecSelferValueTypeArray1234 {
			yyl1050 := r.ReadArrayStart()
			if yyl1050 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1050, 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 yys1051Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1051Slc
	var yyhl1051 bool = l >= 0
	for yyj1051 := 0; ; yyj1051++ {
		if yyhl1051 {
			if yyj1051 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1051Slc = r.DecodeBytes(yys1051Slc, true, true)
		yys1051 := string(yys1051Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1051 {
		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 {
				yyv1053 := &x.TLS
				yym1054 := z.DecBinary()
				_ = yym1054
				if false {
				} else {
					h.decSliceIngressTLS((*[]IngressTLS)(yyv1053), d)
				}
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv1055 := &x.Rules
				yym1056 := z.DecBinary()
				_ = yym1056
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv1055), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1051)
		} // end switch yys1051
	} // end for yyj1051
	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 yyj1057 int
	var yyb1057 bool
	var yyhl1057 bool = l >= 0
	yyj1057++
	if yyhl1057 {
		yyb1057 = yyj1057 > l
	} else {
		yyb1057 = r.CheckBreak()
	}
	if yyb1057 {
		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)
	}
	yyj1057++
	if yyhl1057 {
		yyb1057 = yyj1057 > l
	} else {
		yyb1057 = r.CheckBreak()
	}
	if yyb1057 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TLS = nil
	} else {
		yyv1059 := &x.TLS
		yym1060 := z.DecBinary()
		_ = yym1060
		if false {
		} else {
			h.decSliceIngressTLS((*[]IngressTLS)(yyv1059), d)
		}
	}
	yyj1057++
	if yyhl1057 {
		yyb1057 = yyj1057 > l
	} else {
		yyb1057 = r.CheckBreak()
	}
	if yyb1057 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv1061 := &x.Rules
		yym1062 := z.DecBinary()
		_ = yym1062
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv1061), d)
		}
	}
	for {
		yyj1057++
		if yyhl1057 {
			yyb1057 = yyj1057 > l
		} else {
			yyb1057 = r.CheckBreak()
		}
		if yyb1057 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1057-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 {
		yym1063 := z.EncBinary()
		_ = yym1063
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1064 := !z.EncBinary()
			yy2arr1064 := z.EncBasicHandle().StructToArray
			var yyq1064 [2]bool
			_, _, _ = yysep1064, yyq1064, yy2arr1064
			const yyr1064 bool = false
			yyq1064[0] = len(x.Hosts) != 0
			yyq1064[1] = x.SecretName != ""
			var yynn1064 int
			if yyr1064 || yy2arr1064 {
				r.EncodeArrayStart(2)
			} else {
				yynn1064 = 0
				for _, b := range yyq1064 {
					if b {
						yynn1064++
					}
				}
				r.EncodeMapStart(yynn1064)
				yynn1064 = 0
			}
			if yyr1064 || yy2arr1064 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1064[0] {
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1066 := z.EncBinary()
						_ = yym1066
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1064[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hosts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym1067 := z.EncBinary()
						_ = yym1067
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				}
			}
			if yyr1064 || yy2arr1064 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1064[1] {
					yym1069 := z.EncBinary()
					_ = yym1069
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1064[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("secretName"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1070 := z.EncBinary()
					_ = yym1070
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				}
			}
			if yyr1064 || yy2arr1064 {
				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
	yym1071 := z.DecBinary()
	_ = yym1071
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1072 := r.ContainerType()
		if yyct1072 == codecSelferValueTypeMap1234 {
			yyl1072 := r.ReadMapStart()
			if yyl1072 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1072, d)
			}
		} else if yyct1072 == codecSelferValueTypeArray1234 {
			yyl1072 := r.ReadArrayStart()
			if yyl1072 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1072, 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 yys1073Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1073Slc
	var yyhl1073 bool = l >= 0
	for yyj1073 := 0; ; yyj1073++ {
		if yyhl1073 {
			if yyj1073 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1073Slc = r.DecodeBytes(yys1073Slc, true, true)
		yys1073 := string(yys1073Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1073 {
		case "hosts":
			if r.TryDecodeAsNil() {
				x.Hosts = nil
			} else {
				yyv1074 := &x.Hosts
				yym1075 := z.DecBinary()
				_ = yym1075
				if false {
				} else {
					z.F.DecSliceStringX(yyv1074, false, d)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1073)
		} // end switch yys1073
	} // end for yyj1073
	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 yyj1077 int
	var yyb1077 bool
	var yyhl1077 bool = l >= 0
	yyj1077++
	if yyhl1077 {
		yyb1077 = yyj1077 > l
	} else {
		yyb1077 = r.CheckBreak()
	}
	if yyb1077 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Hosts = nil
	} else {
		yyv1078 := &x.Hosts
		yym1079 := z.DecBinary()
		_ = yym1079
		if false {
		} else {
			z.F.DecSliceStringX(yyv1078, false, d)
		}
	}
	yyj1077++
	if yyhl1077 {
		yyb1077 = yyj1077 > l
	} else {
		yyb1077 = r.CheckBreak()
	}
	if yyb1077 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	for {
		yyj1077++
		if yyhl1077 {
			yyb1077 = yyj1077 > l
		} else {
			yyb1077 = r.CheckBreak()
		}
		if yyb1077 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1077-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 {
		yym1081 := z.EncBinary()
		_ = yym1081
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1082 := !z.EncBinary()
			yy2arr1082 := z.EncBasicHandle().StructToArray
			var yyq1082 [1]bool
			_, _, _ = yysep1082, yyq1082, yy2arr1082
			const yyr1082 bool = false
			yyq1082[0] = true
			var yynn1082 int
			if yyr1082 || yy2arr1082 {
				r.EncodeArrayStart(1)
			} else {
				yynn1082 = 0
				for _, b := range yyq1082 {
					if b {
						yynn1082++
					}
				}
				r.EncodeMapStart(yynn1082)
				yynn1082 = 0
			}
			if yyr1082 || yy2arr1082 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1082[0] {
					yy1084 := &x.LoadBalancer
					yy1084.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1082[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1085 := &x.LoadBalancer
					yy1085.CodecEncodeSelf(e)
				}
			}
			if yyr1082 || yy2arr1082 {
				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
	yym1086 := z.DecBinary()
	_ = yym1086
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1087 := r.ContainerType()
		if yyct1087 == codecSelferValueTypeMap1234 {
			yyl1087 := r.ReadMapStart()
			if yyl1087 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1087, d)
			}
		} else if yyct1087 == codecSelferValueTypeArray1234 {
			yyl1087 := r.ReadArrayStart()
			if yyl1087 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1087, 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 yys1088Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1088Slc
	var yyhl1088 bool = l >= 0
	for yyj1088 := 0; ; yyj1088++ {
		if yyhl1088 {
			if yyj1088 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1088Slc = r.DecodeBytes(yys1088Slc, true, true)
		yys1088 := string(yys1088Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1088 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
			} else {
				yyv1089 := &x.LoadBalancer
				yyv1089.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1088)
		} // end switch yys1088
	} // end for yyj1088
	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 yyj1090 int
	var yyb1090 bool
	var yyhl1090 bool = l >= 0
	yyj1090++
	if yyhl1090 {
		yyb1090 = yyj1090 > l
	} else {
		yyb1090 = r.CheckBreak()
	}
	if yyb1090 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_v1.LoadBalancerStatus{}
	} else {
		yyv1091 := &x.LoadBalancer
		yyv1091.CodecDecodeSelf(d)
	}
	for {
		yyj1090++
		if yyhl1090 {
			yyb1090 = yyj1090 > l
		} else {
			yyb1090 = r.CheckBreak()
		}
		if yyb1090 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1090-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 {
		yym1092 := z.EncBinary()
		_ = yym1092
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1093 := !z.EncBinary()
			yy2arr1093 := z.EncBasicHandle().StructToArray
			var yyq1093 [2]bool
			_, _, _ = yysep1093, yyq1093, yy2arr1093
			const yyr1093 bool = false
			yyq1093[0] = x.Host != ""
			yyq1093[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn1093 int
			if yyr1093 || yy2arr1093 {
				r.EncodeArrayStart(2)
			} else {
				yynn1093 = 0
				for _, b := range yyq1093 {
					if b {
						yynn1093++
					}
				}
				r.EncodeMapStart(yynn1093)
				yynn1093 = 0
			}
			if yyr1093 || yy2arr1093 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1093[0] {
					yym1095 := z.EncBinary()
					_ = yym1095
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1093[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1096 := z.EncBinary()
					_ = yym1096
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn1097 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn1097 = true
				goto LABEL1097
			}
		LABEL1097:
			if yyr1093 || yy2arr1093 {
				if yyn1097 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq1093[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq1093[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn1097 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr1093 || yy2arr1093 {
				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
	yym1098 := z.DecBinary()
	_ = yym1098
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1099 := r.ContainerType()
		if yyct1099 == codecSelferValueTypeMap1234 {
			yyl1099 := r.ReadMapStart()
			if yyl1099 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1099, d)
			}
		} else if yyct1099 == codecSelferValueTypeArray1234 {
			yyl1099 := r.ReadArrayStart()
			if yyl1099 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1099, 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 yys1100Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1100Slc
	var yyhl1100 bool = l >= 0
	for yyj1100 := 0; ; yyj1100++ {
		if yyhl1100 {
			if yyj1100 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1100Slc = r.DecodeBytes(yys1100Slc, true, true)
		yys1100 := string(yys1100Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1100 {
		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, yys1100)
		} // end switch yys1100
	} // end for yyj1100
	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 yyj1103 int
	var yyb1103 bool
	var yyhl1103 bool = l >= 0
	yyj1103++
	if yyhl1103 {
		yyb1103 = yyj1103 > l
	} else {
		yyb1103 = r.CheckBreak()
	}
	if yyb1103 {
		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)
	}
	yyj1103++
	if yyhl1103 {
		yyb1103 = yyj1103 > l
	} else {
		yyb1103 = r.CheckBreak()
	}
	if yyb1103 {
		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 {
		yyj1103++
		if yyhl1103 {
			yyb1103 = yyj1103 > l
		} else {
			yyb1103 = r.CheckBreak()
		}
		if yyb1103 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1103-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 {
		yym1106 := z.EncBinary()
		_ = yym1106
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1107 := !z.EncBinary()
			yy2arr1107 := z.EncBasicHandle().StructToArray
			var yyq1107 [1]bool
			_, _, _ = yysep1107, yyq1107, yy2arr1107
			const yyr1107 bool = false
			yyq1107[0] = x.HTTP != nil
			var yynn1107 int
			if yyr1107 || yy2arr1107 {
				r.EncodeArrayStart(1)
			} else {
				yynn1107 = 0
				for _, b := range yyq1107 {
					if b {
						yynn1107++
					}
				}
				r.EncodeMapStart(yynn1107)
				yynn1107 = 0
			}
			if yyr1107 || yy2arr1107 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1107[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1107[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 yyr1107 || yy2arr1107 {
				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
	yym1109 := z.DecBinary()
	_ = yym1109
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1110 := r.ContainerType()
		if yyct1110 == codecSelferValueTypeMap1234 {
			yyl1110 := r.ReadMapStart()
			if yyl1110 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1110, d)
			}
		} else if yyct1110 == codecSelferValueTypeArray1234 {
			yyl1110 := r.ReadArrayStart()
			if yyl1110 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1110, 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 yys1111Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1111Slc
	var yyhl1111 bool = l >= 0
	for yyj1111 := 0; ; yyj1111++ {
		if yyhl1111 {
			if yyj1111 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1111Slc = r.DecodeBytes(yys1111Slc, true, true)
		yys1111 := string(yys1111Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1111 {
		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, yys1111)
		} // end switch yys1111
	} // end for yyj1111
	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 yyj1113 int
	var yyb1113 bool
	var yyhl1113 bool = l >= 0
	yyj1113++
	if yyhl1113 {
		yyb1113 = yyj1113 > l
	} else {
		yyb1113 = r.CheckBreak()
	}
	if yyb1113 {
		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 {
		yyj1113++
		if yyhl1113 {
			yyb1113 = yyj1113 > l
		} else {
			yyb1113 = r.CheckBreak()
		}
		if yyb1113 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1113-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 {
		yym1115 := z.EncBinary()
		_ = yym1115
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1116 := !z.EncBinary()
			yy2arr1116 := z.EncBasicHandle().StructToArray
			var yyq1116 [1]bool
			_, _, _ = yysep1116, yyq1116, yy2arr1116
			const yyr1116 bool = false
			var yynn1116 int
			if yyr1116 || yy2arr1116 {
				r.EncodeArrayStart(1)
			} else {
				yynn1116 = 1
				for _, b := range yyq1116 {
					if b {
						yynn1116++
					}
				}
				r.EncodeMapStart(yynn1116)
				yynn1116 = 0
			}
			if yyr1116 || yy2arr1116 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym1118 := z.EncBinary()
					_ = yym1118
					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 {
					yym1119 := z.EncBinary()
					_ = yym1119
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr1116 || yy2arr1116 {
				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
	yym1120 := z.DecBinary()
	_ = yym1120
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1121 := r.ContainerType()
		if yyct1121 == codecSelferValueTypeMap1234 {
			yyl1121 := r.ReadMapStart()
			if yyl1121 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1121, d)
			}
		} else if yyct1121 == codecSelferValueTypeArray1234 {
			yyl1121 := r.ReadArrayStart()
			if yyl1121 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1121, 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 yys1122Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1122Slc
	var yyhl1122 bool = l >= 0
	for yyj1122 := 0; ; yyj1122++ {
		if yyhl1122 {
			if yyj1122 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1122Slc = r.DecodeBytes(yys1122Slc, true, true)
		yys1122 := string(yys1122Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1122 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv1123 := &x.Paths
				yym1124 := z.DecBinary()
				_ = yym1124
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1123), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1122)
		} // end switch yys1122
	} // end for yyj1122
	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 yyj1125 int
	var yyb1125 bool
	var yyhl1125 bool = l >= 0
	yyj1125++
	if yyhl1125 {
		yyb1125 = yyj1125 > l
	} else {
		yyb1125 = r.CheckBreak()
	}
	if yyb1125 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv1126 := &x.Paths
		yym1127 := z.DecBinary()
		_ = yym1127
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv1126), d)
		}
	}
	for {
		yyj1125++
		if yyhl1125 {
			yyb1125 = yyj1125 > l
		} else {
			yyb1125 = r.CheckBreak()
		}
		if yyb1125 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1125-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 {
		yym1128 := z.EncBinary()
		_ = yym1128
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1129 := !z.EncBinary()
			yy2arr1129 := z.EncBasicHandle().StructToArray
			var yyq1129 [2]bool
			_, _, _ = yysep1129, yyq1129, yy2arr1129
			const yyr1129 bool = false
			yyq1129[0] = x.Path != ""
			var yynn1129 int
			if yyr1129 || yy2arr1129 {
				r.EncodeArrayStart(2)
			} else {
				yynn1129 = 1
				for _, b := range yyq1129 {
					if b {
						yynn1129++
					}
				}
				r.EncodeMapStart(yynn1129)
				yynn1129 = 0
			}
			if yyr1129 || yy2arr1129 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1129[0] {
					yym1131 := z.EncBinary()
					_ = yym1131
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1129[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1132 := z.EncBinary()
					_ = yym1132
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr1129 || yy2arr1129 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1134 := &x.Backend
				yy1134.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1135 := &x.Backend
				yy1135.CodecEncodeSelf(e)
			}
			if yyr1129 || yy2arr1129 {
				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
	yym1136 := z.DecBinary()
	_ = yym1136
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1137 := r.ContainerType()
		if yyct1137 == codecSelferValueTypeMap1234 {
			yyl1137 := r.ReadMapStart()
			if yyl1137 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1137, d)
			}
		} else if yyct1137 == codecSelferValueTypeArray1234 {
			yyl1137 := r.ReadArrayStart()
			if yyl1137 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1137, 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 yys1138Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1138Slc
	var yyhl1138 bool = l >= 0
	for yyj1138 := 0; ; yyj1138++ {
		if yyhl1138 {
			if yyj1138 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1138Slc = r.DecodeBytes(yys1138Slc, true, true)
		yys1138 := string(yys1138Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1138 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv1140 := &x.Backend
				yyv1140.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1138)
		} // end switch yys1138
	} // end for yyj1138
	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 yyj1141 int
	var yyb1141 bool
	var yyhl1141 bool = l >= 0
	yyj1141++
	if yyhl1141 {
		yyb1141 = yyj1141 > l
	} else {
		yyb1141 = r.CheckBreak()
	}
	if yyb1141 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj1141++
	if yyhl1141 {
		yyb1141 = yyj1141 > l
	} else {
		yyb1141 = r.CheckBreak()
	}
	if yyb1141 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv1143 := &x.Backend
		yyv1143.CodecDecodeSelf(d)
	}
	for {
		yyj1141++
		if yyhl1141 {
			yyb1141 = yyj1141 > l
		} else {
			yyb1141 = r.CheckBreak()
		}
		if yyb1141 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1141-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 {
		yym1144 := z.EncBinary()
		_ = yym1144
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1145 := !z.EncBinary()
			yy2arr1145 := z.EncBasicHandle().StructToArray
			var yyq1145 [2]bool
			_, _, _ = yysep1145, yyq1145, yy2arr1145
			const yyr1145 bool = false
			var yynn1145 int
			if yyr1145 || yy2arr1145 {
				r.EncodeArrayStart(2)
			} else {
				yynn1145 = 2
				for _, b := range yyq1145 {
					if b {
						yynn1145++
					}
				}
				r.EncodeMapStart(yynn1145)
				yynn1145 = 0
			}
			if yyr1145 || yy2arr1145 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1147 := z.EncBinary()
				_ = yym1147
				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)
				yym1148 := z.EncBinary()
				_ = yym1148
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr1145 || yy2arr1145 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1150 := &x.ServicePort
				yym1151 := z.EncBinary()
				_ = yym1151
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1150) {
				} else if !yym1151 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1150)
				} else {
					z.EncFallback(yy1150)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1152 := &x.ServicePort
				yym1153 := z.EncBinary()
				_ = yym1153
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1152) {
				} else if !yym1153 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy1152)
				} else {
					z.EncFallback(yy1152)
				}
			}
			if yyr1145 || yy2arr1145 {
				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
	yym1154 := z.DecBinary()
	_ = yym1154
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1155 := r.ContainerType()
		if yyct1155 == codecSelferValueTypeMap1234 {
			yyl1155 := r.ReadMapStart()
			if yyl1155 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1155, d)
			}
		} else if yyct1155 == codecSelferValueTypeArray1234 {
			yyl1155 := r.ReadArrayStart()
			if yyl1155 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1155, 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 yys1156Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1156Slc
	var yyhl1156 bool = l >= 0
	for yyj1156 := 0; ; yyj1156++ {
		if yyhl1156 {
			if yyj1156 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1156Slc = r.DecodeBytes(yys1156Slc, true, true)
		yys1156 := string(yys1156Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1156 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg5_intstr.IntOrString{}
			} else {
				yyv1158 := &x.ServicePort
				yym1159 := z.DecBinary()
				_ = yym1159
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1158) {
				} else if !yym1159 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1158)
				} else {
					z.DecFallback(yyv1158, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1156)
		} // end switch yys1156
	} // end for yyj1156
	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 yyj1160 int
	var yyb1160 bool
	var yyhl1160 bool = l >= 0
	yyj1160++
	if yyhl1160 {
		yyb1160 = yyj1160 > l
	} else {
		yyb1160 = r.CheckBreak()
	}
	if yyb1160 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj1160++
	if yyhl1160 {
		yyb1160 = yyj1160 > l
	} else {
		yyb1160 = r.CheckBreak()
	}
	if yyb1160 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg5_intstr.IntOrString{}
	} else {
		yyv1162 := &x.ServicePort
		yym1163 := z.DecBinary()
		_ = yym1163
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1162) {
		} else if !yym1163 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1162)
		} else {
			z.DecFallback(yyv1162, false)
		}
	}
	for {
		yyj1160++
		if yyhl1160 {
			yyb1160 = yyj1160 > l
		} else {
			yyb1160 = r.CheckBreak()
		}
		if yyb1160 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1160-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 {
		yym1164 := z.EncBinary()
		_ = yym1164
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1165 := !z.EncBinary()
			yy2arr1165 := z.EncBasicHandle().StructToArray
			var yyq1165 [4]bool
			_, _, _ = yysep1165, yyq1165, yy2arr1165
			const yyr1165 bool = false
			yyq1165[0] = x.Kind != ""
			yyq1165[1] = x.APIVersion != ""
			var yynn1165 int
			if yyr1165 || yy2arr1165 {
				r.EncodeArrayStart(4)
			} else {
				yynn1165 = 2
				for _, b := range yyq1165 {
					if b {
						yynn1165++
					}
				}
				r.EncodeMapStart(yynn1165)
				yynn1165 = 0
			}
			if yyr1165 || yy2arr1165 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1165[0] {
					yym1167 := z.EncBinary()
					_ = yym1167
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1165[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1168 := z.EncBinary()
					_ = yym1168
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1165 || yy2arr1165 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1165[1] {
					yym1170 := z.EncBinary()
					_ = yym1170
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1165[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1171 := z.EncBinary()
					_ = yym1171
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1165 || yy2arr1165 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1173 := z.EncBinary()
				_ = yym1173
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("export"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1174 := z.EncBinary()
				_ = yym1174
				if false {
				} else {
					r.EncodeBool(bool(x.Export))
				}
			}
			if yyr1165 || yy2arr1165 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1176 := z.EncBinary()
				_ = yym1176
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("exact"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1177 := z.EncBinary()
				_ = yym1177
				if false {
				} else {
					r.EncodeBool(bool(x.Exact))
				}
			}
			if yyr1165 || yy2arr1165 {
				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
	yym1178 := z.DecBinary()
	_ = yym1178
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1179 := r.ContainerType()
		if yyct1179 == codecSelferValueTypeMap1234 {
			yyl1179 := r.ReadMapStart()
			if yyl1179 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1179, d)
			}
		} else if yyct1179 == codecSelferValueTypeArray1234 {
			yyl1179 := r.ReadArrayStart()
			if yyl1179 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1179, 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 yys1180Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1180Slc
	var yyhl1180 bool = l >= 0
	for yyj1180 := 0; ; yyj1180++ {
		if yyhl1180 {
			if yyj1180 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1180Slc = r.DecodeBytes(yys1180Slc, true, true)
		yys1180 := string(yys1180Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1180 {
		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, yys1180)
		} // end switch yys1180
	} // end for yyj1180
	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 yyj1185 int
	var yyb1185 bool
	var yyhl1185 bool = l >= 0
	yyj1185++
	if yyhl1185 {
		yyb1185 = yyj1185 > l
	} else {
		yyb1185 = r.CheckBreak()
	}
	if yyb1185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1185++
	if yyhl1185 {
		yyb1185 = yyj1185 > l
	} else {
		yyb1185 = r.CheckBreak()
	}
	if yyb1185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1185++
	if yyhl1185 {
		yyb1185 = yyj1185 > l
	} else {
		yyb1185 = r.CheckBreak()
	}
	if yyb1185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Export = false
	} else {
		x.Export = bool(r.DecodeBool())
	}
	yyj1185++
	if yyhl1185 {
		yyb1185 = yyj1185 > l
	} else {
		yyb1185 = r.CheckBreak()
	}
	if yyb1185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Exact = false
	} else {
		x.Exact = bool(r.DecodeBool())
	}
	for {
		yyj1185++
		if yyhl1185 {
			yyb1185 = yyj1185 > l
		} else {
			yyb1185 = r.CheckBreak()
		}
		if yyb1185 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1185-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 {
		yym1190 := z.EncBinary()
		_ = yym1190
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1191 := !z.EncBinary()
			yy2arr1191 := z.EncBasicHandle().StructToArray
			var yyq1191 [2]bool
			_, _, _ = yysep1191, yyq1191, yy2arr1191
			const yyr1191 bool = false
			yyq1191[0] = len(x.MatchLabels) != 0
			yyq1191[1] = len(x.MatchExpressions) != 0
			var yynn1191 int
			if yyr1191 || yy2arr1191 {
				r.EncodeArrayStart(2)
			} else {
				yynn1191 = 0
				for _, b := range yyq1191 {
					if b {
						yynn1191++
					}
				}
				r.EncodeMapStart(yynn1191)
				yynn1191 = 0
			}
			if yyr1191 || yy2arr1191 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1191[0] {
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1193 := z.EncBinary()
						_ = yym1193
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1191[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchLabels"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchLabels == nil {
						r.EncodeNil()
					} else {
						yym1194 := z.EncBinary()
						_ = yym1194
						if false {
						} else {
							z.F.EncMapStringStringV(x.MatchLabels, false, e)
						}
					}
				}
			}
			if yyr1191 || yy2arr1191 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1191[1] {
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1196 := z.EncBinary()
						_ = yym1196
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1191[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("matchExpressions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.MatchExpressions == nil {
						r.EncodeNil()
					} else {
						yym1197 := z.EncBinary()
						_ = yym1197
						if false {
						} else {
							h.encSliceLabelSelectorRequirement(([]LabelSelectorRequirement)(x.MatchExpressions), e)
						}
					}
				}
			}
			if yyr1191 || yy2arr1191 {
				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
	yym1198 := z.DecBinary()
	_ = yym1198
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1199 := r.ContainerType()
		if yyct1199 == codecSelferValueTypeMap1234 {
			yyl1199 := r.ReadMapStart()
			if yyl1199 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1199, d)
			}
		} else if yyct1199 == codecSelferValueTypeArray1234 {
			yyl1199 := r.ReadArrayStart()
			if yyl1199 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1199, 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 yys1200Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1200Slc
	var yyhl1200 bool = l >= 0
	for yyj1200 := 0; ; yyj1200++ {
		if yyhl1200 {
			if yyj1200 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1200Slc = r.DecodeBytes(yys1200Slc, true, true)
		yys1200 := string(yys1200Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1200 {
		case "matchLabels":
			if r.TryDecodeAsNil() {
				x.MatchLabels = nil
			} else {
				yyv1201 := &x.MatchLabels
				yym1202 := z.DecBinary()
				_ = yym1202
				if false {
				} else {
					z.F.DecMapStringStringX(yyv1201, false, d)
				}
			}
		case "matchExpressions":
			if r.TryDecodeAsNil() {
				x.MatchExpressions = nil
			} else {
				yyv1203 := &x.MatchExpressions
				yym1204 := z.DecBinary()
				_ = yym1204
				if false {
				} else {
					h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1203), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1200)
		} // end switch yys1200
	} // end for yyj1200
	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 yyj1205 int
	var yyb1205 bool
	var yyhl1205 bool = l >= 0
	yyj1205++
	if yyhl1205 {
		yyb1205 = yyj1205 > l
	} else {
		yyb1205 = r.CheckBreak()
	}
	if yyb1205 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchLabels = nil
	} else {
		yyv1206 := &x.MatchLabels
		yym1207 := z.DecBinary()
		_ = yym1207
		if false {
		} else {
			z.F.DecMapStringStringX(yyv1206, false, d)
		}
	}
	yyj1205++
	if yyhl1205 {
		yyb1205 = yyj1205 > l
	} else {
		yyb1205 = r.CheckBreak()
	}
	if yyb1205 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MatchExpressions = nil
	} else {
		yyv1208 := &x.MatchExpressions
		yym1209 := z.DecBinary()
		_ = yym1209
		if false {
		} else {
			h.decSliceLabelSelectorRequirement((*[]LabelSelectorRequirement)(yyv1208), d)
		}
	}
	for {
		yyj1205++
		if yyhl1205 {
			yyb1205 = yyj1205 > l
		} else {
			yyb1205 = r.CheckBreak()
		}
		if yyb1205 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1205-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 {
		yym1210 := z.EncBinary()
		_ = yym1210
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1211 := !z.EncBinary()
			yy2arr1211 := z.EncBasicHandle().StructToArray
			var yyq1211 [3]bool
			_, _, _ = yysep1211, yyq1211, yy2arr1211
			const yyr1211 bool = false
			yyq1211[2] = len(x.Values) != 0
			var yynn1211 int
			if yyr1211 || yy2arr1211 {
				r.EncodeArrayStart(3)
			} else {
				yynn1211 = 2
				for _, b := range yyq1211 {
					if b {
						yynn1211++
					}
				}
				r.EncodeMapStart(yynn1211)
				yynn1211 = 0
			}
			if yyr1211 || yy2arr1211 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1213 := z.EncBinary()
				_ = yym1213
				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)
				yym1214 := z.EncBinary()
				_ = yym1214
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Key))
				}
			}
			if yyr1211 || yy2arr1211 {
				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 yyr1211 || yy2arr1211 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1211[2] {
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1217 := z.EncBinary()
						_ = yym1217
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1211[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("values"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Values == nil {
						r.EncodeNil()
					} else {
						yym1218 := z.EncBinary()
						_ = yym1218
						if false {
						} else {
							z.F.EncSliceStringV(x.Values, false, e)
						}
					}
				}
			}
			if yyr1211 || yy2arr1211 {
				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
	yym1219 := z.DecBinary()
	_ = yym1219
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1220 := r.ContainerType()
		if yyct1220 == codecSelferValueTypeMap1234 {
			yyl1220 := r.ReadMapStart()
			if yyl1220 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1220, d)
			}
		} else if yyct1220 == codecSelferValueTypeArray1234 {
			yyl1220 := r.ReadArrayStart()
			if yyl1220 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1220, 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 yys1221Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1221Slc
	var yyhl1221 bool = l >= 0
	for yyj1221 := 0; ; yyj1221++ {
		if yyhl1221 {
			if yyj1221 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1221Slc = r.DecodeBytes(yys1221Slc, true, true)
		yys1221 := string(yys1221Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1221 {
		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 {
				yyv1224 := &x.Values
				yym1225 := z.DecBinary()
				_ = yym1225
				if false {
				} else {
					z.F.DecSliceStringX(yyv1224, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1221)
		} // end switch yys1221
	} // end for yyj1221
	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 yyj1226 int
	var yyb1226 bool
	var yyhl1226 bool = l >= 0
	yyj1226++
	if yyhl1226 {
		yyb1226 = yyj1226 > l
	} else {
		yyb1226 = r.CheckBreak()
	}
	if yyb1226 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Key = ""
	} else {
		x.Key = string(r.DecodeString())
	}
	yyj1226++
	if yyhl1226 {
		yyb1226 = yyj1226 > l
	} else {
		yyb1226 = r.CheckBreak()
	}
	if yyb1226 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Operator = ""
	} else {
		x.Operator = LabelSelectorOperator(r.DecodeString())
	}
	yyj1226++
	if yyhl1226 {
		yyb1226 = yyj1226 > l
	} else {
		yyb1226 = r.CheckBreak()
	}
	if yyb1226 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Values = nil
	} else {
		yyv1229 := &x.Values
		yym1230 := z.DecBinary()
		_ = yym1230
		if false {
		} else {
			z.F.DecSliceStringX(yyv1229, false, d)
		}
	}
	for {
		yyj1226++
		if yyhl1226 {
			yyb1226 = yyj1226 > l
		} else {
			yyb1226 = r.CheckBreak()
		}
		if yyb1226 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1226-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x LabelSelectorOperator) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1231 := z.EncBinary()
	_ = yym1231
	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
	yym1232 := z.DecBinary()
	_ = yym1232
	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 {
		yym1233 := z.EncBinary()
		_ = yym1233
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1234 := !z.EncBinary()
			yy2arr1234 := z.EncBasicHandle().StructToArray
			var yyq1234 [5]bool
			_, _, _ = yysep1234, yyq1234, yy2arr1234
			const yyr1234 bool = false
			yyq1234[0] = x.Kind != ""
			yyq1234[1] = x.APIVersion != ""
			yyq1234[2] = true
			yyq1234[3] = true
			yyq1234[4] = true
			var yynn1234 int
			if yyr1234 || yy2arr1234 {
				r.EncodeArrayStart(5)
			} else {
				yynn1234 = 0
				for _, b := range yyq1234 {
					if b {
						yynn1234++
					}
				}
				r.EncodeMapStart(yynn1234)
				yynn1234 = 0
			}
			if yyr1234 || yy2arr1234 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1234[0] {
					yym1236 := z.EncBinary()
					_ = yym1236
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1234[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1237 := z.EncBinary()
					_ = yym1237
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1234 || yy2arr1234 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1234[1] {
					yym1239 := z.EncBinary()
					_ = yym1239
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1234[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1240 := z.EncBinary()
					_ = yym1240
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1234 || yy2arr1234 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1234[2] {
					yy1242 := &x.ObjectMeta
					yy1242.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1234[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1243 := &x.ObjectMeta
					yy1243.CodecEncodeSelf(e)
				}
			}
			if yyr1234 || yy2arr1234 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1234[3] {
					yy1245 := &x.Spec
					yy1245.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1234[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1246 := &x.Spec
					yy1246.CodecEncodeSelf(e)
				}
			}
			if yyr1234 || yy2arr1234 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1234[4] {
					yy1248 := &x.Status
					yy1248.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1234[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1249 := &x.Status
					yy1249.CodecEncodeSelf(e)
				}
			}
			if yyr1234 || yy2arr1234 {
				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
	yym1250 := z.DecBinary()
	_ = yym1250
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1251 := r.ContainerType()
		if yyct1251 == codecSelferValueTypeMap1234 {
			yyl1251 := r.ReadMapStart()
			if yyl1251 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1251, d)
			}
		} else if yyct1251 == codecSelferValueTypeArray1234 {
			yyl1251 := r.ReadArrayStart()
			if yyl1251 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1251, 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 yys1252Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1252Slc
	var yyhl1252 bool = l >= 0
	for yyj1252 := 0; ; yyj1252++ {
		if yyhl1252 {
			if yyj1252 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1252Slc = r.DecodeBytes(yys1252Slc, true, true)
		yys1252 := string(yys1252Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1252 {
		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 {
				yyv1255 := &x.ObjectMeta
				yyv1255.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv1256 := &x.Spec
				yyv1256.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv1257 := &x.Status
				yyv1257.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1252)
		} // end switch yys1252
	} // end for yyj1252
	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 yyj1258 int
	var yyb1258 bool
	var yyhl1258 bool = l >= 0
	yyj1258++
	if yyhl1258 {
		yyb1258 = yyj1258 > l
	} else {
		yyb1258 = r.CheckBreak()
	}
	if yyb1258 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1258++
	if yyhl1258 {
		yyb1258 = yyj1258 > l
	} else {
		yyb1258 = r.CheckBreak()
	}
	if yyb1258 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1258++
	if yyhl1258 {
		yyb1258 = yyj1258 > l
	} else {
		yyb1258 = r.CheckBreak()
	}
	if yyb1258 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1261 := &x.ObjectMeta
		yyv1261.CodecDecodeSelf(d)
	}
	yyj1258++
	if yyhl1258 {
		yyb1258 = yyj1258 > l
	} else {
		yyb1258 = r.CheckBreak()
	}
	if yyb1258 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv1262 := &x.Spec
		yyv1262.CodecDecodeSelf(d)
	}
	yyj1258++
	if yyhl1258 {
		yyb1258 = yyj1258 > l
	} else {
		yyb1258 = r.CheckBreak()
	}
	if yyb1258 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv1263 := &x.Status
		yyv1263.CodecDecodeSelf(d)
	}
	for {
		yyj1258++
		if yyhl1258 {
			yyb1258 = yyj1258 > l
		} else {
			yyb1258 = r.CheckBreak()
		}
		if yyb1258 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1258-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 {
		yym1264 := z.EncBinary()
		_ = yym1264
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1265 := !z.EncBinary()
			yy2arr1265 := z.EncBasicHandle().StructToArray
			var yyq1265 [4]bool
			_, _, _ = yysep1265, yyq1265, yy2arr1265
			const yyr1265 bool = false
			yyq1265[0] = x.Kind != ""
			yyq1265[1] = x.APIVersion != ""
			yyq1265[2] = true
			var yynn1265 int
			if yyr1265 || yy2arr1265 {
				r.EncodeArrayStart(4)
			} else {
				yynn1265 = 1
				for _, b := range yyq1265 {
					if b {
						yynn1265++
					}
				}
				r.EncodeMapStart(yynn1265)
				yynn1265 = 0
			}
			if yyr1265 || yy2arr1265 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1265[0] {
					yym1267 := z.EncBinary()
					_ = yym1267
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1265[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1268 := z.EncBinary()
					_ = yym1268
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1265 || yy2arr1265 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1265[1] {
					yym1270 := z.EncBinary()
					_ = yym1270
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1265[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1271 := z.EncBinary()
					_ = yym1271
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1265 || yy2arr1265 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1265[2] {
					yy1273 := &x.ListMeta
					yym1274 := z.EncBinary()
					_ = yym1274
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1273) {
					} else {
						z.EncFallback(yy1273)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1265[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1275 := &x.ListMeta
					yym1276 := z.EncBinary()
					_ = yym1276
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1275) {
					} else {
						z.EncFallback(yy1275)
					}
				}
			}
			if yyr1265 || yy2arr1265 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1278 := z.EncBinary()
					_ = yym1278
					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 {
					yym1279 := z.EncBinary()
					_ = yym1279
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr1265 || yy2arr1265 {
				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
	yym1280 := z.DecBinary()
	_ = yym1280
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1281 := r.ContainerType()
		if yyct1281 == codecSelferValueTypeMap1234 {
			yyl1281 := r.ReadMapStart()
			if yyl1281 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1281, d)
			}
		} else if yyct1281 == codecSelferValueTypeArray1234 {
			yyl1281 := r.ReadArrayStart()
			if yyl1281 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1281, 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 yys1282Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1282Slc
	var yyhl1282 bool = l >= 0
	for yyj1282 := 0; ; yyj1282++ {
		if yyhl1282 {
			if yyj1282 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1282Slc = r.DecodeBytes(yys1282Slc, true, true)
		yys1282 := string(yys1282Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1282 {
		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 {
				yyv1285 := &x.ListMeta
				yym1286 := z.DecBinary()
				_ = yym1286
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1285) {
				} else {
					z.DecFallback(yyv1285, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1287 := &x.Items
				yym1288 := z.DecBinary()
				_ = yym1288
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv1287), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1282)
		} // end switch yys1282
	} // end for yyj1282
	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 yyj1289 int
	var yyb1289 bool
	var yyhl1289 bool = l >= 0
	yyj1289++
	if yyhl1289 {
		yyb1289 = yyj1289 > l
	} else {
		yyb1289 = r.CheckBreak()
	}
	if yyb1289 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1289++
	if yyhl1289 {
		yyb1289 = yyj1289 > l
	} else {
		yyb1289 = r.CheckBreak()
	}
	if yyb1289 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1289++
	if yyhl1289 {
		yyb1289 = yyj1289 > l
	} else {
		yyb1289 = r.CheckBreak()
	}
	if yyb1289 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1292 := &x.ListMeta
		yym1293 := z.DecBinary()
		_ = yym1293
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1292) {
		} else {
			z.DecFallback(yyv1292, false)
		}
	}
	yyj1289++
	if yyhl1289 {
		yyb1289 = yyj1289 > l
	} else {
		yyb1289 = r.CheckBreak()
	}
	if yyb1289 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1294 := &x.Items
		yym1295 := z.DecBinary()
		_ = yym1295
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv1294), d)
		}
	}
	for {
		yyj1289++
		if yyhl1289 {
			yyb1289 = yyj1289 > l
		} else {
			yyb1289 = r.CheckBreak()
		}
		if yyb1289 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1289-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 {
		yym1296 := z.EncBinary()
		_ = yym1296
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1297 := !z.EncBinary()
			yy2arr1297 := z.EncBasicHandle().StructToArray
			var yyq1297 [4]bool
			_, _, _ = yysep1297, yyq1297, yy2arr1297
			const yyr1297 bool = false
			yyq1297[0] = x.Replicas != nil
			yyq1297[1] = x.MinReadySeconds != 0
			yyq1297[2] = x.Selector != nil
			yyq1297[3] = true
			var yynn1297 int
			if yyr1297 || yy2arr1297 {
				r.EncodeArrayStart(4)
			} else {
				yynn1297 = 0
				for _, b := range yyq1297 {
					if b {
						yynn1297++
					}
				}
				r.EncodeMapStart(yynn1297)
				yynn1297 = 0
			}
			if yyr1297 || yy2arr1297 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1297[0] {
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1299 := *x.Replicas
						yym1300 := z.EncBinary()
						_ = yym1300
						if false {
						} else {
							r.EncodeInt(int64(yy1299))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1297[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Replicas == nil {
						r.EncodeNil()
					} else {
						yy1301 := *x.Replicas
						yym1302 := z.EncBinary()
						_ = yym1302
						if false {
						} else {
							r.EncodeInt(int64(yy1301))
						}
					}
				}
			}
			if yyr1297 || yy2arr1297 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1297[1] {
					yym1304 := z.EncBinary()
					_ = yym1304
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1297[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1305 := z.EncBinary()
					_ = yym1305
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr1297 || yy2arr1297 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1297[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						x.Selector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1297[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 yyr1297 || yy2arr1297 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1297[3] {
					yy1308 := &x.Template
					yy1308.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1297[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1309 := &x.Template
					yy1309.CodecEncodeSelf(e)
				}
			}
			if yyr1297 || yy2arr1297 {
				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
	yym1310 := z.DecBinary()
	_ = yym1310
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1311 := r.ContainerType()
		if yyct1311 == codecSelferValueTypeMap1234 {
			yyl1311 := r.ReadMapStart()
			if yyl1311 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1311, d)
			}
		} else if yyct1311 == codecSelferValueTypeArray1234 {
			yyl1311 := r.ReadArrayStart()
			if yyl1311 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1311, 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 yys1312Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1312Slc
	var yyhl1312 bool = l >= 0
	for yyj1312 := 0; ; yyj1312++ {
		if yyhl1312 {
			if yyj1312 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1312Slc = r.DecodeBytes(yys1312Slc, true, true)
		yys1312 := string(yys1312Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1312 {
		case "replicas":
			if r.TryDecodeAsNil() {
				if x.Replicas != nil {
					x.Replicas = nil
				}
			} else {
				if x.Replicas == nil {
					x.Replicas = new(int32)
				}
				yym1314 := z.DecBinary()
				_ = yym1314
				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 {
				yyv1317 := &x.Template
				yyv1317.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1312)
		} // end switch yys1312
	} // end for yyj1312
	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 yyj1318 int
	var yyb1318 bool
	var yyhl1318 bool = l >= 0
	yyj1318++
	if yyhl1318 {
		yyb1318 = yyj1318 > l
	} else {
		yyb1318 = r.CheckBreak()
	}
	if yyb1318 {
		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)
		}
		yym1320 := z.DecBinary()
		_ = yym1320
		if false {
		} else {
			*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
		}
	}
	yyj1318++
	if yyhl1318 {
		yyb1318 = yyj1318 > l
	} else {
		yyb1318 = r.CheckBreak()
	}
	if yyb1318 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj1318++
	if yyhl1318 {
		yyb1318 = yyj1318 > l
	} else {
		yyb1318 = r.CheckBreak()
	}
	if yyb1318 {
		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)
	}
	yyj1318++
	if yyhl1318 {
		yyb1318 = yyj1318 > l
	} else {
		yyb1318 = r.CheckBreak()
	}
	if yyb1318 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_v1.PodTemplateSpec{}
	} else {
		yyv1323 := &x.Template
		yyv1323.CodecDecodeSelf(d)
	}
	for {
		yyj1318++
		if yyhl1318 {
			yyb1318 = yyj1318 > l
		} else {
			yyb1318 = r.CheckBreak()
		}
		if yyb1318 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1318-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 {
		yym1324 := z.EncBinary()
		_ = yym1324
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1325 := !z.EncBinary()
			yy2arr1325 := z.EncBasicHandle().StructToArray
			var yyq1325 [6]bool
			_, _, _ = yysep1325, yyq1325, yy2arr1325
			const yyr1325 bool = false
			yyq1325[1] = x.FullyLabeledReplicas != 0
			yyq1325[2] = x.ReadyReplicas != 0
			yyq1325[3] = x.AvailableReplicas != 0
			yyq1325[4] = x.ObservedGeneration != 0
			yyq1325[5] = len(x.Conditions) != 0
			var yynn1325 int
			if yyr1325 || yy2arr1325 {
				r.EncodeArrayStart(6)
			} else {
				yynn1325 = 1
				for _, b := range yyq1325 {
					if b {
						yynn1325++
					}
				}
				r.EncodeMapStart(yynn1325)
				yynn1325 = 0
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1327 := z.EncBinary()
				_ = yym1327
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1328 := z.EncBinary()
				_ = yym1328
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1325[1] {
					yym1330 := z.EncBinary()
					_ = yym1330
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1325[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1331 := z.EncBinary()
					_ = yym1331
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				}
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1325[2] {
					yym1333 := z.EncBinary()
					_ = yym1333
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1325[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1334 := z.EncBinary()
					_ = yym1334
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				}
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1325[3] {
					yym1336 := z.EncBinary()
					_ = yym1336
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1325[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1337 := z.EncBinary()
					_ = yym1337
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1325[4] {
					yym1339 := z.EncBinary()
					_ = yym1339
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq1325[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1340 := z.EncBinary()
					_ = yym1340
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr1325 || yy2arr1325 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1325[5] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym1342 := z.EncBinary()
						_ = yym1342
						if false {
						} else {
							h.encSliceReplicaSetCondition(([]ReplicaSetCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1325[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym1343 := z.EncBinary()
						_ = yym1343
						if false {
						} else {
							h.encSliceReplicaSetCondition(([]ReplicaSetCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr1325 || yy2arr1325 {
				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
	yym1344 := z.DecBinary()
	_ = yym1344
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1345 := r.ContainerType()
		if yyct1345 == codecSelferValueTypeMap1234 {
			yyl1345 := r.ReadMapStart()
			if yyl1345 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1345, d)
			}
		} else if yyct1345 == codecSelferValueTypeArray1234 {
			yyl1345 := r.ReadArrayStart()
			if yyl1345 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1345, 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 yys1346Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1346Slc
	var yyhl1346 bool = l >= 0
	for yyj1346 := 0; ; yyj1346++ {
		if yyhl1346 {
			if yyj1346 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1346Slc = r.DecodeBytes(yys1346Slc, true, true)
		yys1346 := string(yys1346Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1346 {
		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))
			}
		case "conditions":
			if r.TryDecodeAsNil() {
				x.Conditions = nil
			} else {
				yyv1352 := &x.Conditions
				yym1353 := z.DecBinary()
				_ = yym1353
				if false {
				} else {
					h.decSliceReplicaSetCondition((*[]ReplicaSetCondition)(yyv1352), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1346)
		} // end switch yys1346
	} // end for yyj1346
	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 yyj1354 int
	var yyb1354 bool
	var yyhl1354 bool = l >= 0
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FullyLabeledReplicas = 0
	} else {
		x.FullyLabeledReplicas = int32(r.DecodeInt(32))
	}
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadyReplicas = 0
	} else {
		x.ReadyReplicas = int32(r.DecodeInt(32))
	}
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	yyj1354++
	if yyhl1354 {
		yyb1354 = yyj1354 > l
	} else {
		yyb1354 = r.CheckBreak()
	}
	if yyb1354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv1360 := &x.Conditions
		yym1361 := z.DecBinary()
		_ = yym1361
		if false {
		} else {
			h.decSliceReplicaSetCondition((*[]ReplicaSetCondition)(yyv1360), d)
		}
	}
	for {
		yyj1354++
		if yyhl1354 {
			yyb1354 = yyj1354 > l
		} else {
			yyb1354 = r.CheckBreak()
		}
		if yyb1354 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1354-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

func (x *ReplicaSetCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1364 := z.EncBinary()
		_ = yym1364
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1365 := !z.EncBinary()
			yy2arr1365 := z.EncBasicHandle().StructToArray
			var yyq1365 [6]bool
			_, _, _ = yysep1365, yyq1365, yy2arr1365
			const yyr1365 bool = false
			yyq1365[2] = true
			yyq1365[3] = true
			yyq1365[4] = x.Reason != ""
			yyq1365[5] = x.Message != ""
			var yynn1365 int
			if yyr1365 || yy2arr1365 {
				r.EncodeArrayStart(6)
			} else {
				yynn1365 = 2
				for _, b := range yyq1365 {
					if b {
						yynn1365++
					}
				}
				r.EncodeMapStart(yynn1365)
				yynn1365 = 0
			}
			if yyr1365 || yy2arr1365 {
				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 yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1368 := z.EncBinary()
				_ = yym1368
				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)
				yym1369 := z.EncBinary()
				_ = yym1369
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1365[2] {
					yy1371 := &x.LastProbeTime
					yym1372 := z.EncBinary()
					_ = yym1372
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1371) {
					} else if yym1372 {
						z.EncBinaryMarshal(yy1371)
					} else if !yym1372 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy1371)
					} else {
						z.EncFallback(yy1371)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1365[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastProbeTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1373 := &x.LastProbeTime
					yym1374 := z.EncBinary()
					_ = yym1374
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1373) {
					} else if yym1374 {
						z.EncBinaryMarshal(yy1373)
					} else if !yym1374 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy1373)
					} else {
						z.EncFallback(yy1373)
					}
				}
			}
			if yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1365[3] {
					yy1376 := &x.LastTransitionTime
					yym1377 := z.EncBinary()
					_ = yym1377
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1376) {
					} else if yym1377 {
						z.EncBinaryMarshal(yy1376)
					} else if !yym1377 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy1376)
					} else {
						z.EncFallback(yy1376)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1365[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1378 := &x.LastTransitionTime
					yym1379 := z.EncBinary()
					_ = yym1379
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1378) {
					} else if yym1379 {
						z.EncBinaryMarshal(yy1378)
					} else if !yym1379 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy1378)
					} else {
						z.EncFallback(yy1378)
					}
				}
			}
			if yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1365[4] {
					yym1381 := z.EncBinary()
					_ = yym1381
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1365[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1382 := z.EncBinary()
					_ = yym1382
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1365[5] {
					yym1384 := z.EncBinary()
					_ = yym1384
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1365[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1385 := z.EncBinary()
					_ = yym1385
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr1365 || yy2arr1365 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

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

func (x *ReplicaSetCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1388Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1388Slc
	var yyhl1388 bool = l >= 0
	for yyj1388 := 0; ; yyj1388++ {
		if yyhl1388 {
			if yyj1388 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1388Slc = r.DecodeBytes(yys1388Slc, true, true)
		yys1388 := string(yys1388Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1388 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = ReplicaSetConditionType(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 {
				yyv1391 := &x.LastProbeTime
				yym1392 := z.DecBinary()
				_ = yym1392
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1391) {
				} else if yym1392 {
					z.DecBinaryUnmarshal(yyv1391)
				} else if !yym1392 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1391)
				} else {
					z.DecFallback(yyv1391, false)
				}
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv1393 := &x.LastTransitionTime
				yym1394 := z.DecBinary()
				_ = yym1394
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1393) {
				} else if yym1394 {
					z.DecBinaryUnmarshal(yyv1393)
				} else if !yym1394 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv1393)
				} else {
					z.DecFallback(yyv1393, 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, yys1388)
		} // end switch yys1388
	} // end for yyj1388
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ReplicaSetCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj1397 int
	var yyb1397 bool
	var yyhl1397 bool = l >= 0
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = ReplicaSetConditionType(r.DecodeString())
	}
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_v1.ConditionStatus(r.DecodeString())
	}
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastProbeTime = pkg1_unversioned.Time{}
	} else {
		yyv1400 := &x.LastProbeTime
		yym1401 := z.DecBinary()
		_ = yym1401
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1400) {
		} else if yym1401 {
			z.DecBinaryUnmarshal(yyv1400)
		} else if !yym1401 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1400)
		} else {
			z.DecFallback(yyv1400, false)
		}
	}
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv1402 := &x.LastTransitionTime
		yym1403 := z.DecBinary()
		_ = yym1403
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1402) {
		} else if yym1403 {
			z.DecBinaryUnmarshal(yyv1402)
		} else if !yym1403 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv1402)
		} else {
			z.DecFallback(yyv1402, false)
		}
	}
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj1397++
	if yyhl1397 {
		yyb1397 = yyj1397 > l
	} else {
		yyb1397 = r.CheckBreak()
	}
	if yyb1397 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj1397++
		if yyhl1397 {
			yyb1397 = yyj1397 > l
		} else {
			yyb1397 = r.CheckBreak()
		}
		if yyb1397 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1397-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 {
		yym1406 := z.EncBinary()
		_ = yym1406
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1407 := !z.EncBinary()
			yy2arr1407 := z.EncBasicHandle().StructToArray
			var yyq1407 [4]bool
			_, _, _ = yysep1407, yyq1407, yy2arr1407
			const yyr1407 bool = false
			yyq1407[0] = x.Kind != ""
			yyq1407[1] = x.APIVersion != ""
			yyq1407[2] = true
			yyq1407[3] = true
			var yynn1407 int
			if yyr1407 || yy2arr1407 {
				r.EncodeArrayStart(4)
			} else {
				yynn1407 = 0
				for _, b := range yyq1407 {
					if b {
						yynn1407++
					}
				}
				r.EncodeMapStart(yynn1407)
				yynn1407 = 0
			}
			if yyr1407 || yy2arr1407 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1407[0] {
					yym1409 := z.EncBinary()
					_ = yym1409
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1407[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1410 := z.EncBinary()
					_ = yym1410
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1407 || yy2arr1407 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1407[1] {
					yym1412 := z.EncBinary()
					_ = yym1412
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1407[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1413 := z.EncBinary()
					_ = yym1413
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1407 || yy2arr1407 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1407[2] {
					yy1415 := &x.ObjectMeta
					yy1415.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1407[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1416 := &x.ObjectMeta
					yy1416.CodecEncodeSelf(e)
				}
			}
			if yyr1407 || yy2arr1407 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1407[3] {
					yy1418 := &x.Spec
					yy1418.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1407[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1419 := &x.Spec
					yy1419.CodecEncodeSelf(e)
				}
			}
			if yyr1407 || yy2arr1407 {
				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
	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 *PodSecurityPolicy) 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 "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 {
				yyv1425 := &x.ObjectMeta
				yyv1425.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = PodSecurityPolicySpec{}
			} else {
				yyv1426 := &x.Spec
				yyv1426.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1422)
		} // end switch yys1422
	} // end for yyj1422
	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 yyj1427 int
	var yyb1427 bool
	var yyhl1427 bool = l >= 0
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1430 := &x.ObjectMeta
		yyv1430.CodecDecodeSelf(d)
	}
	yyj1427++
	if yyhl1427 {
		yyb1427 = yyj1427 > l
	} else {
		yyb1427 = r.CheckBreak()
	}
	if yyb1427 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = PodSecurityPolicySpec{}
	} else {
		yyv1431 := &x.Spec
		yyv1431.CodecDecodeSelf(d)
	}
	for {
		yyj1427++
		if yyhl1427 {
			yyb1427 = yyj1427 > l
		} else {
			yyb1427 = r.CheckBreak()
		}
		if yyb1427 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1427-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 {
		yym1432 := z.EncBinary()
		_ = yym1432
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1433 := !z.EncBinary()
			yy2arr1433 := z.EncBasicHandle().StructToArray
			var yyq1433 [14]bool
			_, _, _ = yysep1433, yyq1433, yy2arr1433
			const yyr1433 bool = false
			yyq1433[0] = x.Privileged != false
			yyq1433[1] = len(x.DefaultAddCapabilities) != 0
			yyq1433[2] = len(x.RequiredDropCapabilities) != 0
			yyq1433[3] = len(x.AllowedCapabilities) != 0
			yyq1433[4] = len(x.Volumes) != 0
			yyq1433[5] = x.HostNetwork != false
			yyq1433[6] = len(x.HostPorts) != 0
			yyq1433[7] = x.HostPID != false
			yyq1433[8] = x.HostIPC != false
			yyq1433[13] = x.ReadOnlyRootFilesystem != false
			var yynn1433 int
			if yyr1433 || yy2arr1433 {
				r.EncodeArrayStart(14)
			} else {
				yynn1433 = 4
				for _, b := range yyq1433 {
					if b {
						yynn1433++
					}
				}
				r.EncodeMapStart(yynn1433)
				yynn1433 = 0
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[0] {
					yym1435 := z.EncBinary()
					_ = yym1435
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1433[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("privileged"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1436 := z.EncBinary()
					_ = yym1436
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[1] {
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1438 := z.EncBinary()
						_ = yym1438
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1433[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1439 := z.EncBinary()
						_ = yym1439
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[2] {
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1441 := z.EncBinary()
						_ = yym1441
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1433[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1442 := z.EncBinary()
						_ = yym1442
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[3] {
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1444 := z.EncBinary()
						_ = yym1444
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1433[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1445 := z.EncBinary()
						_ = yym1445
						if false {
						} else {
							h.encSlicev1_Capability(([]pkg2_v1.Capability)(x.AllowedCapabilities), e)
						}
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[4] {
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1447 := z.EncBinary()
						_ = yym1447
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1433[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("volumes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1448 := z.EncBinary()
						_ = yym1448
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[5] {
					yym1450 := z.EncBinary()
					_ = yym1450
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1433[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1451 := z.EncBinary()
					_ = yym1451
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[6] {
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1453 := z.EncBinary()
						_ = yym1453
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1433[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1454 := z.EncBinary()
						_ = yym1454
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[7] {
					yym1456 := z.EncBinary()
					_ = yym1456
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1433[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1457 := z.EncBinary()
					_ = yym1457
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[8] {
					yym1459 := z.EncBinary()
					_ = yym1459
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1433[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1460 := z.EncBinary()
					_ = yym1460
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1462 := &x.SELinux
				yy1462.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1463 := &x.SELinux
				yy1463.CodecEncodeSelf(e)
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1465 := &x.RunAsUser
				yy1465.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1466 := &x.RunAsUser
				yy1466.CodecEncodeSelf(e)
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1468 := &x.SupplementalGroups
				yy1468.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1469 := &x.SupplementalGroups
				yy1469.CodecEncodeSelf(e)
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1471 := &x.FSGroup
				yy1471.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1472 := &x.FSGroup
				yy1472.CodecEncodeSelf(e)
			}
			if yyr1433 || yy2arr1433 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1433[13] {
					yym1474 := z.EncBinary()
					_ = yym1474
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq1433[13] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1475 := z.EncBinary()
					_ = yym1475
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				}
			}
			if yyr1433 || yy2arr1433 {
				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
	yym1476 := z.DecBinary()
	_ = yym1476
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1477 := r.ContainerType()
		if yyct1477 == codecSelferValueTypeMap1234 {
			yyl1477 := r.ReadMapStart()
			if yyl1477 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1477, d)
			}
		} else if yyct1477 == codecSelferValueTypeArray1234 {
			yyl1477 := r.ReadArrayStart()
			if yyl1477 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1477, 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 yys1478Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1478Slc
	var yyhl1478 bool = l >= 0
	for yyj1478 := 0; ; yyj1478++ {
		if yyhl1478 {
			if yyj1478 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1478Slc = r.DecodeBytes(yys1478Slc, true, true)
		yys1478 := string(yys1478Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1478 {
		case "privileged":
			if r.TryDecodeAsNil() {
				x.Privileged = false
			} else {
				x.Privileged = bool(r.DecodeBool())
			}
		case "defaultAddCapabilities":
			if r.TryDecodeAsNil() {
				x.DefaultAddCapabilities = nil
			} else {
				yyv1480 := &x.DefaultAddCapabilities
				yym1481 := z.DecBinary()
				_ = yym1481
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1480), d)
				}
			}
		case "requiredDropCapabilities":
			if r.TryDecodeAsNil() {
				x.RequiredDropCapabilities = nil
			} else {
				yyv1482 := &x.RequiredDropCapabilities
				yym1483 := z.DecBinary()
				_ = yym1483
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1482), d)
				}
			}
		case "allowedCapabilities":
			if r.TryDecodeAsNil() {
				x.AllowedCapabilities = nil
			} else {
				yyv1484 := &x.AllowedCapabilities
				yym1485 := z.DecBinary()
				_ = yym1485
				if false {
				} else {
					h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1484), d)
				}
			}
		case "volumes":
			if r.TryDecodeAsNil() {
				x.Volumes = nil
			} else {
				yyv1486 := &x.Volumes
				yym1487 := z.DecBinary()
				_ = yym1487
				if false {
				} else {
					h.decSliceFSType((*[]FSType)(yyv1486), d)
				}
			}
		case "hostNetwork":
			if r.TryDecodeAsNil() {
				x.HostNetwork = false
			} else {
				x.HostNetwork = bool(r.DecodeBool())
			}
		case "hostPorts":
			if r.TryDecodeAsNil() {
				x.HostPorts = nil
			} else {
				yyv1489 := &x.HostPorts
				yym1490 := z.DecBinary()
				_ = yym1490
				if false {
				} else {
					h.decSliceHostPortRange((*[]HostPortRange)(yyv1489), 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 {
				yyv1493 := &x.SELinux
				yyv1493.CodecDecodeSelf(d)
			}
		case "runAsUser":
			if r.TryDecodeAsNil() {
				x.RunAsUser = RunAsUserStrategyOptions{}
			} else {
				yyv1494 := &x.RunAsUser
				yyv1494.CodecDecodeSelf(d)
			}
		case "supplementalGroups":
			if r.TryDecodeAsNil() {
				x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
			} else {
				yyv1495 := &x.SupplementalGroups
				yyv1495.CodecDecodeSelf(d)
			}
		case "fsGroup":
			if r.TryDecodeAsNil() {
				x.FSGroup = FSGroupStrategyOptions{}
			} else {
				yyv1496 := &x.FSGroup
				yyv1496.CodecDecodeSelf(d)
			}
		case "readOnlyRootFilesystem":
			if r.TryDecodeAsNil() {
				x.ReadOnlyRootFilesystem = false
			} else {
				x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1478)
		} // end switch yys1478
	} // end for yyj1478
	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 yyj1498 int
	var yyb1498 bool
	var yyhl1498 bool = l >= 0
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Privileged = false
	} else {
		x.Privileged = bool(r.DecodeBool())
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DefaultAddCapabilities = nil
	} else {
		yyv1500 := &x.DefaultAddCapabilities
		yym1501 := z.DecBinary()
		_ = yym1501
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1500), d)
		}
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RequiredDropCapabilities = nil
	} else {
		yyv1502 := &x.RequiredDropCapabilities
		yym1503 := z.DecBinary()
		_ = yym1503
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1502), d)
		}
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AllowedCapabilities = nil
	} else {
		yyv1504 := &x.AllowedCapabilities
		yym1505 := z.DecBinary()
		_ = yym1505
		if false {
		} else {
			h.decSlicev1_Capability((*[]pkg2_v1.Capability)(yyv1504), d)
		}
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Volumes = nil
	} else {
		yyv1506 := &x.Volumes
		yym1507 := z.DecBinary()
		_ = yym1507
		if false {
		} else {
			h.decSliceFSType((*[]FSType)(yyv1506), d)
		}
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostNetwork = false
	} else {
		x.HostNetwork = bool(r.DecodeBool())
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPorts = nil
	} else {
		yyv1509 := &x.HostPorts
		yym1510 := z.DecBinary()
		_ = yym1510
		if false {
		} else {
			h.decSliceHostPortRange((*[]HostPortRange)(yyv1509), d)
		}
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPID = false
	} else {
		x.HostPID = bool(r.DecodeBool())
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostIPC = false
	} else {
		x.HostIPC = bool(r.DecodeBool())
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SELinux = SELinuxStrategyOptions{}
	} else {
		yyv1513 := &x.SELinux
		yyv1513.CodecDecodeSelf(d)
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RunAsUser = RunAsUserStrategyOptions{}
	} else {
		yyv1514 := &x.RunAsUser
		yyv1514.CodecDecodeSelf(d)
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
	} else {
		yyv1515 := &x.SupplementalGroups
		yyv1515.CodecDecodeSelf(d)
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FSGroup = FSGroupStrategyOptions{}
	} else {
		yyv1516 := &x.FSGroup
		yyv1516.CodecDecodeSelf(d)
	}
	yyj1498++
	if yyhl1498 {
		yyb1498 = yyj1498 > l
	} else {
		yyb1498 = r.CheckBreak()
	}
	if yyb1498 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadOnlyRootFilesystem = false
	} else {
		x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
	}
	for {
		yyj1498++
		if yyhl1498 {
			yyb1498 = yyj1498 > l
		} else {
			yyb1498 = r.CheckBreak()
		}
		if yyb1498 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1498-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1518 := z.EncBinary()
	_ = yym1518
	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
	yym1519 := z.DecBinary()
	_ = yym1519
	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 {
		yym1520 := z.EncBinary()
		_ = yym1520
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1521 := !z.EncBinary()
			yy2arr1521 := z.EncBasicHandle().StructToArray
			var yyq1521 [2]bool
			_, _, _ = yysep1521, yyq1521, yy2arr1521
			const yyr1521 bool = false
			var yynn1521 int
			if yyr1521 || yy2arr1521 {
				r.EncodeArrayStart(2)
			} else {
				yynn1521 = 2
				for _, b := range yyq1521 {
					if b {
						yynn1521++
					}
				}
				r.EncodeMapStart(yynn1521)
				yynn1521 = 0
			}
			if yyr1521 || yy2arr1521 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1523 := z.EncBinary()
				_ = yym1523
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1524 := z.EncBinary()
				_ = yym1524
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1521 || yy2arr1521 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1526 := z.EncBinary()
				_ = yym1526
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1527 := z.EncBinary()
				_ = yym1527
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1521 || yy2arr1521 {
				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
	yym1528 := z.DecBinary()
	_ = yym1528
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1529 := r.ContainerType()
		if yyct1529 == codecSelferValueTypeMap1234 {
			yyl1529 := r.ReadMapStart()
			if yyl1529 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1529, d)
			}
		} else if yyct1529 == codecSelferValueTypeArray1234 {
			yyl1529 := r.ReadArrayStart()
			if yyl1529 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1529, 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 yys1530Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1530Slc
	var yyhl1530 bool = l >= 0
	for yyj1530 := 0; ; yyj1530++ {
		if yyhl1530 {
			if yyj1530 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1530Slc = r.DecodeBytes(yys1530Slc, true, true)
		yys1530 := string(yys1530Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1530 {
		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, yys1530)
		} // end switch yys1530
	} // end for yyj1530
	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 yyj1533 int
	var yyb1533 bool
	var yyhl1533 bool = l >= 0
	yyj1533++
	if yyhl1533 {
		yyb1533 = yyj1533 > l
	} else {
		yyb1533 = r.CheckBreak()
	}
	if yyb1533 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int32(r.DecodeInt(32))
	}
	yyj1533++
	if yyhl1533 {
		yyb1533 = yyj1533 > l
	} else {
		yyb1533 = r.CheckBreak()
	}
	if yyb1533 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int32(r.DecodeInt(32))
	}
	for {
		yyj1533++
		if yyhl1533 {
			yyb1533 = yyj1533 > l
		} else {
			yyb1533 = r.CheckBreak()
		}
		if yyb1533 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1533-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 {
		yym1536 := z.EncBinary()
		_ = yym1536
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1537 := !z.EncBinary()
			yy2arr1537 := z.EncBasicHandle().StructToArray
			var yyq1537 [2]bool
			_, _, _ = yysep1537, yyq1537, yy2arr1537
			const yyr1537 bool = false
			yyq1537[1] = x.SELinuxOptions != nil
			var yynn1537 int
			if yyr1537 || yy2arr1537 {
				r.EncodeArrayStart(2)
			} else {
				yynn1537 = 1
				for _, b := range yyq1537 {
					if b {
						yynn1537++
					}
				}
				r.EncodeMapStart(yynn1537)
				yynn1537 = 0
			}
			if yyr1537 || yy2arr1537 {
				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 yyr1537 || yy2arr1537 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1537[1] {
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1537[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 yyr1537 || yy2arr1537 {
				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
	yym1540 := z.DecBinary()
	_ = yym1540
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1541 := r.ContainerType()
		if yyct1541 == codecSelferValueTypeMap1234 {
			yyl1541 := r.ReadMapStart()
			if yyl1541 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1541, d)
			}
		} else if yyct1541 == codecSelferValueTypeArray1234 {
			yyl1541 := r.ReadArrayStart()
			if yyl1541 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1541, 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 yys1542Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1542Slc
	var yyhl1542 bool = l >= 0
	for yyj1542 := 0; ; yyj1542++ {
		if yyhl1542 {
			if yyj1542 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1542Slc = r.DecodeBytes(yys1542Slc, true, true)
		yys1542 := string(yys1542Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1542 {
		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, yys1542)
		} // end switch yys1542
	} // end for yyj1542
	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 yyj1545 int
	var yyb1545 bool
	var yyhl1545 bool = l >= 0
	yyj1545++
	if yyhl1545 {
		yyb1545 = yyj1545 > l
	} else {
		yyb1545 = r.CheckBreak()
	}
	if yyb1545 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SELinuxStrategy(r.DecodeString())
	}
	yyj1545++
	if yyhl1545 {
		yyb1545 = yyj1545 > l
	} else {
		yyb1545 = r.CheckBreak()
	}
	if yyb1545 {
		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 {
		yyj1545++
		if yyhl1545 {
			yyb1545 = yyj1545 > l
		} else {
			yyb1545 = r.CheckBreak()
		}
		if yyb1545 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1545-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1548 := z.EncBinary()
	_ = yym1548
	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
	yym1549 := z.DecBinary()
	_ = yym1549
	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 {
		yym1550 := z.EncBinary()
		_ = yym1550
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1551 := !z.EncBinary()
			yy2arr1551 := z.EncBasicHandle().StructToArray
			var yyq1551 [2]bool
			_, _, _ = yysep1551, yyq1551, yy2arr1551
			const yyr1551 bool = false
			yyq1551[1] = len(x.Ranges) != 0
			var yynn1551 int
			if yyr1551 || yy2arr1551 {
				r.EncodeArrayStart(2)
			} else {
				yynn1551 = 1
				for _, b := range yyq1551 {
					if b {
						yynn1551++
					}
				}
				r.EncodeMapStart(yynn1551)
				yynn1551 = 0
			}
			if yyr1551 || yy2arr1551 {
				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 yyr1551 || yy2arr1551 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1551[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1554 := z.EncBinary()
						_ = yym1554
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1551[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1555 := z.EncBinary()
						_ = yym1555
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1551 || yy2arr1551 {
				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
	yym1556 := z.DecBinary()
	_ = yym1556
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1557 := r.ContainerType()
		if yyct1557 == codecSelferValueTypeMap1234 {
			yyl1557 := r.ReadMapStart()
			if yyl1557 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1557, d)
			}
		} else if yyct1557 == codecSelferValueTypeArray1234 {
			yyl1557 := r.ReadArrayStart()
			if yyl1557 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1557, 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 yys1558Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1558Slc
	var yyhl1558 bool = l >= 0
	for yyj1558 := 0; ; yyj1558++ {
		if yyhl1558 {
			if yyj1558 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1558Slc = r.DecodeBytes(yys1558Slc, true, true)
		yys1558 := string(yys1558Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1558 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = RunAsUserStrategy(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1560 := &x.Ranges
				yym1561 := z.DecBinary()
				_ = yym1561
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1560), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1558)
		} // end switch yys1558
	} // end for yyj1558
	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 yyj1562 int
	var yyb1562 bool
	var yyhl1562 bool = l >= 0
	yyj1562++
	if yyhl1562 {
		yyb1562 = yyj1562 > l
	} else {
		yyb1562 = r.CheckBreak()
	}
	if yyb1562 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = RunAsUserStrategy(r.DecodeString())
	}
	yyj1562++
	if yyhl1562 {
		yyb1562 = yyj1562 > l
	} else {
		yyb1562 = r.CheckBreak()
	}
	if yyb1562 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1564 := &x.Ranges
		yym1565 := z.DecBinary()
		_ = yym1565
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1564), d)
		}
	}
	for {
		yyj1562++
		if yyhl1562 {
			yyb1562 = yyj1562 > l
		} else {
			yyb1562 = r.CheckBreak()
		}
		if yyb1562 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1562-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 {
		yym1566 := z.EncBinary()
		_ = yym1566
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1567 := !z.EncBinary()
			yy2arr1567 := z.EncBasicHandle().StructToArray
			var yyq1567 [2]bool
			_, _, _ = yysep1567, yyq1567, yy2arr1567
			const yyr1567 bool = false
			var yynn1567 int
			if yyr1567 || yy2arr1567 {
				r.EncodeArrayStart(2)
			} else {
				yynn1567 = 2
				for _, b := range yyq1567 {
					if b {
						yynn1567++
					}
				}
				r.EncodeMapStart(yynn1567)
				yynn1567 = 0
			}
			if yyr1567 || yy2arr1567 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1569 := z.EncBinary()
				_ = yym1569
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1570 := z.EncBinary()
				_ = yym1570
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1567 || yy2arr1567 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1572 := z.EncBinary()
				_ = yym1572
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1573 := z.EncBinary()
				_ = yym1573
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1567 || yy2arr1567 {
				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
	yym1574 := z.DecBinary()
	_ = yym1574
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1575 := r.ContainerType()
		if yyct1575 == codecSelferValueTypeMap1234 {
			yyl1575 := r.ReadMapStart()
			if yyl1575 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1575, d)
			}
		} else if yyct1575 == codecSelferValueTypeArray1234 {
			yyl1575 := r.ReadArrayStart()
			if yyl1575 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1575, 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 yys1576Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1576Slc
	var yyhl1576 bool = l >= 0
	for yyj1576 := 0; ; yyj1576++ {
		if yyhl1576 {
			if yyj1576 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1576Slc = r.DecodeBytes(yys1576Slc, true, true)
		yys1576 := string(yys1576Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1576 {
		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, yys1576)
		} // end switch yys1576
	} // end for yyj1576
	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 yyj1579 int
	var yyb1579 bool
	var yyhl1579 bool = l >= 0
	yyj1579++
	if yyhl1579 {
		yyb1579 = yyj1579 > l
	} else {
		yyb1579 = r.CheckBreak()
	}
	if yyb1579 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int64(r.DecodeInt(64))
	}
	yyj1579++
	if yyhl1579 {
		yyb1579 = yyj1579 > l
	} else {
		yyb1579 = r.CheckBreak()
	}
	if yyb1579 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int64(r.DecodeInt(64))
	}
	for {
		yyj1579++
		if yyhl1579 {
			yyb1579 = yyj1579 > l
		} else {
			yyb1579 = r.CheckBreak()
		}
		if yyb1579 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1579-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1582 := z.EncBinary()
	_ = yym1582
	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
	yym1583 := z.DecBinary()
	_ = yym1583
	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 {
		yym1584 := z.EncBinary()
		_ = yym1584
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1585 := !z.EncBinary()
			yy2arr1585 := z.EncBasicHandle().StructToArray
			var yyq1585 [2]bool
			_, _, _ = yysep1585, yyq1585, yy2arr1585
			const yyr1585 bool = false
			yyq1585[0] = x.Rule != ""
			yyq1585[1] = len(x.Ranges) != 0
			var yynn1585 int
			if yyr1585 || yy2arr1585 {
				r.EncodeArrayStart(2)
			} else {
				yynn1585 = 0
				for _, b := range yyq1585 {
					if b {
						yynn1585++
					}
				}
				r.EncodeMapStart(yynn1585)
				yynn1585 = 0
			}
			if yyr1585 || yy2arr1585 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1585[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1585[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1585 || yy2arr1585 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1585[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1588 := z.EncBinary()
						_ = yym1588
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1585[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1589 := z.EncBinary()
						_ = yym1589
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1585 || yy2arr1585 {
				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
	yym1590 := z.DecBinary()
	_ = yym1590
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1591 := r.ContainerType()
		if yyct1591 == codecSelferValueTypeMap1234 {
			yyl1591 := r.ReadMapStart()
			if yyl1591 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1591, d)
			}
		} else if yyct1591 == codecSelferValueTypeArray1234 {
			yyl1591 := r.ReadArrayStart()
			if yyl1591 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1591, 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 yys1592Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1592Slc
	var yyhl1592 bool = l >= 0
	for yyj1592 := 0; ; yyj1592++ {
		if yyhl1592 {
			if yyj1592 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1592Slc = r.DecodeBytes(yys1592Slc, true, true)
		yys1592 := string(yys1592Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1592 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = FSGroupStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1594 := &x.Ranges
				yym1595 := z.DecBinary()
				_ = yym1595
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1594), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1592)
		} // end switch yys1592
	} // end for yyj1592
	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 yyj1596 int
	var yyb1596 bool
	var yyhl1596 bool = l >= 0
	yyj1596++
	if yyhl1596 {
		yyb1596 = yyj1596 > l
	} else {
		yyb1596 = r.CheckBreak()
	}
	if yyb1596 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = FSGroupStrategyType(r.DecodeString())
	}
	yyj1596++
	if yyhl1596 {
		yyb1596 = yyj1596 > l
	} else {
		yyb1596 = r.CheckBreak()
	}
	if yyb1596 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1598 := &x.Ranges
		yym1599 := z.DecBinary()
		_ = yym1599
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1598), d)
		}
	}
	for {
		yyj1596++
		if yyhl1596 {
			yyb1596 = yyj1596 > l
		} else {
			yyb1596 = r.CheckBreak()
		}
		if yyb1596 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1596-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1600 := z.EncBinary()
	_ = yym1600
	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
	yym1601 := z.DecBinary()
	_ = yym1601
	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 {
		yym1602 := z.EncBinary()
		_ = yym1602
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1603 := !z.EncBinary()
			yy2arr1603 := z.EncBasicHandle().StructToArray
			var yyq1603 [2]bool
			_, _, _ = yysep1603, yyq1603, yy2arr1603
			const yyr1603 bool = false
			yyq1603[0] = x.Rule != ""
			yyq1603[1] = len(x.Ranges) != 0
			var yynn1603 int
			if yyr1603 || yy2arr1603 {
				r.EncodeArrayStart(2)
			} else {
				yynn1603 = 0
				for _, b := range yyq1603 {
					if b {
						yynn1603++
					}
				}
				r.EncodeMapStart(yynn1603)
				yynn1603 = 0
			}
			if yyr1603 || yy2arr1603 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1603[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1603[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1603 || yy2arr1603 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1603[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1606 := z.EncBinary()
						_ = yym1606
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1603[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1607 := z.EncBinary()
						_ = yym1607
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1603 || yy2arr1603 {
				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
	yym1608 := z.DecBinary()
	_ = yym1608
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1609 := r.ContainerType()
		if yyct1609 == codecSelferValueTypeMap1234 {
			yyl1609 := r.ReadMapStart()
			if yyl1609 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1609, d)
			}
		} else if yyct1609 == codecSelferValueTypeArray1234 {
			yyl1609 := r.ReadArrayStart()
			if yyl1609 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1609, 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 yys1610Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1610Slc
	var yyhl1610 bool = l >= 0
	for yyj1610 := 0; ; yyj1610++ {
		if yyhl1610 {
			if yyj1610 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1610Slc = r.DecodeBytes(yys1610Slc, true, true)
		yys1610 := string(yys1610Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1610 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1612 := &x.Ranges
				yym1613 := z.DecBinary()
				_ = yym1613
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1612), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1610)
		} // end switch yys1610
	} // end for yyj1610
	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 yyj1614 int
	var yyb1614 bool
	var yyhl1614 bool = l >= 0
	yyj1614++
	if yyhl1614 {
		yyb1614 = yyj1614 > l
	} else {
		yyb1614 = r.CheckBreak()
	}
	if yyb1614 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
	}
	yyj1614++
	if yyhl1614 {
		yyb1614 = yyj1614 > l
	} else {
		yyb1614 = r.CheckBreak()
	}
	if yyb1614 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1616 := &x.Ranges
		yym1617 := z.DecBinary()
		_ = yym1617
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1616), d)
		}
	}
	for {
		yyj1614++
		if yyhl1614 {
			yyb1614 = yyj1614 > l
		} else {
			yyb1614 = r.CheckBreak()
		}
		if yyb1614 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1614-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1618 := z.EncBinary()
	_ = yym1618
	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
	yym1619 := z.DecBinary()
	_ = yym1619
	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 {
		yym1620 := z.EncBinary()
		_ = yym1620
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1621 := !z.EncBinary()
			yy2arr1621 := z.EncBasicHandle().StructToArray
			var yyq1621 [4]bool
			_, _, _ = yysep1621, yyq1621, yy2arr1621
			const yyr1621 bool = false
			yyq1621[0] = x.Kind != ""
			yyq1621[1] = x.APIVersion != ""
			yyq1621[2] = true
			var yynn1621 int
			if yyr1621 || yy2arr1621 {
				r.EncodeArrayStart(4)
			} else {
				yynn1621 = 1
				for _, b := range yyq1621 {
					if b {
						yynn1621++
					}
				}
				r.EncodeMapStart(yynn1621)
				yynn1621 = 0
			}
			if yyr1621 || yy2arr1621 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1621[0] {
					yym1623 := z.EncBinary()
					_ = yym1623
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1621[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1624 := z.EncBinary()
					_ = yym1624
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1621 || yy2arr1621 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1621[1] {
					yym1626 := z.EncBinary()
					_ = yym1626
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1621[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1627 := z.EncBinary()
					_ = yym1627
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1621 || yy2arr1621 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1621[2] {
					yy1629 := &x.ListMeta
					yym1630 := z.EncBinary()
					_ = yym1630
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1629) {
					} else {
						z.EncFallback(yy1629)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1621[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1631 := &x.ListMeta
					yym1632 := z.EncBinary()
					_ = yym1632
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1631) {
					} else {
						z.EncFallback(yy1631)
					}
				}
			}
			if yyr1621 || yy2arr1621 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1634 := z.EncBinary()
					_ = yym1634
					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 {
					yym1635 := z.EncBinary()
					_ = yym1635
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			}
			if yyr1621 || yy2arr1621 {
				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
	yym1636 := z.DecBinary()
	_ = yym1636
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1637 := r.ContainerType()
		if yyct1637 == codecSelferValueTypeMap1234 {
			yyl1637 := r.ReadMapStart()
			if yyl1637 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1637, d)
			}
		} else if yyct1637 == codecSelferValueTypeArray1234 {
			yyl1637 := r.ReadArrayStart()
			if yyl1637 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1637, 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 yys1638Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1638Slc
	var yyhl1638 bool = l >= 0
	for yyj1638 := 0; ; yyj1638++ {
		if yyhl1638 {
			if yyj1638 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1638Slc = r.DecodeBytes(yys1638Slc, true, true)
		yys1638 := string(yys1638Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1638 {
		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 {
				yyv1641 := &x.ListMeta
				yym1642 := z.DecBinary()
				_ = yym1642
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1641) {
				} else {
					z.DecFallback(yyv1641, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1643 := &x.Items
				yym1644 := z.DecBinary()
				_ = yym1644
				if false {
				} else {
					h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1643), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1638)
		} // end switch yys1638
	} // end for yyj1638
	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 yyj1645 int
	var yyb1645 bool
	var yyhl1645 bool = l >= 0
	yyj1645++
	if yyhl1645 {
		yyb1645 = yyj1645 > l
	} else {
		yyb1645 = r.CheckBreak()
	}
	if yyb1645 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1645++
	if yyhl1645 {
		yyb1645 = yyj1645 > l
	} else {
		yyb1645 = r.CheckBreak()
	}
	if yyb1645 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1645++
	if yyhl1645 {
		yyb1645 = yyj1645 > l
	} else {
		yyb1645 = r.CheckBreak()
	}
	if yyb1645 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1648 := &x.ListMeta
		yym1649 := z.DecBinary()
		_ = yym1649
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1648) {
		} else {
			z.DecFallback(yyv1648, false)
		}
	}
	yyj1645++
	if yyhl1645 {
		yyb1645 = yyj1645 > l
	} else {
		yyb1645 = r.CheckBreak()
	}
	if yyb1645 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1650 := &x.Items
		yym1651 := z.DecBinary()
		_ = yym1651
		if false {
		} else {
			h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1650), d)
		}
	}
	for {
		yyj1645++
		if yyhl1645 {
			yyb1645 = yyj1645 > l
		} else {
			yyb1645 = r.CheckBreak()
		}
		if yyb1645 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1645-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 {
		yym1652 := z.EncBinary()
		_ = yym1652
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1653 := !z.EncBinary()
			yy2arr1653 := z.EncBasicHandle().StructToArray
			var yyq1653 [4]bool
			_, _, _ = yysep1653, yyq1653, yy2arr1653
			const yyr1653 bool = false
			yyq1653[0] = x.Kind != ""
			yyq1653[1] = x.APIVersion != ""
			yyq1653[2] = true
			yyq1653[3] = true
			var yynn1653 int
			if yyr1653 || yy2arr1653 {
				r.EncodeArrayStart(4)
			} else {
				yynn1653 = 0
				for _, b := range yyq1653 {
					if b {
						yynn1653++
					}
				}
				r.EncodeMapStart(yynn1653)
				yynn1653 = 0
			}
			if yyr1653 || yy2arr1653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1653[0] {
					yym1655 := z.EncBinary()
					_ = yym1655
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1653[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1656 := z.EncBinary()
					_ = yym1656
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1653 || yy2arr1653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1653[1] {
					yym1658 := z.EncBinary()
					_ = yym1658
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1653[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1659 := z.EncBinary()
					_ = yym1659
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1653 || yy2arr1653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1653[2] {
					yy1661 := &x.ObjectMeta
					yy1661.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1653[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1662 := &x.ObjectMeta
					yy1662.CodecEncodeSelf(e)
				}
			}
			if yyr1653 || yy2arr1653 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1653[3] {
					yy1664 := &x.Spec
					yy1664.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1653[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1665 := &x.Spec
					yy1665.CodecEncodeSelf(e)
				}
			}
			if yyr1653 || yy2arr1653 {
				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
	yym1666 := z.DecBinary()
	_ = yym1666
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1667 := r.ContainerType()
		if yyct1667 == codecSelferValueTypeMap1234 {
			yyl1667 := r.ReadMapStart()
			if yyl1667 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1667, d)
			}
		} else if yyct1667 == codecSelferValueTypeArray1234 {
			yyl1667 := r.ReadArrayStart()
			if yyl1667 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1667, 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 yys1668Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1668Slc
	var yyhl1668 bool = l >= 0
	for yyj1668 := 0; ; yyj1668++ {
		if yyhl1668 {
			if yyj1668 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1668Slc = r.DecodeBytes(yys1668Slc, true, true)
		yys1668 := string(yys1668Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1668 {
		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 {
				yyv1671 := &x.ObjectMeta
				yyv1671.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = NetworkPolicySpec{}
			} else {
				yyv1672 := &x.Spec
				yyv1672.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1668)
		} // end switch yys1668
	} // end for yyj1668
	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 yyj1673 int
	var yyb1673 bool
	var yyhl1673 bool = l >= 0
	yyj1673++
	if yyhl1673 {
		yyb1673 = yyj1673 > l
	} else {
		yyb1673 = r.CheckBreak()
	}
	if yyb1673 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1673++
	if yyhl1673 {
		yyb1673 = yyj1673 > l
	} else {
		yyb1673 = r.CheckBreak()
	}
	if yyb1673 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1673++
	if yyhl1673 {
		yyb1673 = yyj1673 > l
	} else {
		yyb1673 = r.CheckBreak()
	}
	if yyb1673 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_v1.ObjectMeta{}
	} else {
		yyv1676 := &x.ObjectMeta
		yyv1676.CodecDecodeSelf(d)
	}
	yyj1673++
	if yyhl1673 {
		yyb1673 = yyj1673 > l
	} else {
		yyb1673 = r.CheckBreak()
	}
	if yyb1673 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = NetworkPolicySpec{}
	} else {
		yyv1677 := &x.Spec
		yyv1677.CodecDecodeSelf(d)
	}
	for {
		yyj1673++
		if yyhl1673 {
			yyb1673 = yyj1673 > l
		} else {
			yyb1673 = r.CheckBreak()
		}
		if yyb1673 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1673-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 {
		yym1678 := z.EncBinary()
		_ = yym1678
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1679 := !z.EncBinary()
			yy2arr1679 := z.EncBasicHandle().StructToArray
			var yyq1679 [2]bool
			_, _, _ = yysep1679, yyq1679, yy2arr1679
			const yyr1679 bool = false
			yyq1679[1] = len(x.Ingress) != 0
			var yynn1679 int
			if yyr1679 || yy2arr1679 {
				r.EncodeArrayStart(2)
			} else {
				yynn1679 = 1
				for _, b := range yyq1679 {
					if b {
						yynn1679++
					}
				}
				r.EncodeMapStart(yynn1679)
				yynn1679 = 0
			}
			if yyr1679 || yy2arr1679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1681 := &x.PodSelector
				yy1681.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1682 := &x.PodSelector
				yy1682.CodecEncodeSelf(e)
			}
			if yyr1679 || yy2arr1679 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1679[1] {
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1684 := z.EncBinary()
						_ = yym1684
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1679[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ingress"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1685 := z.EncBinary()
						_ = yym1685
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				}
			}
			if yyr1679 || yy2arr1679 {
				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
	yym1686 := z.DecBinary()
	_ = yym1686
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1687 := r.ContainerType()
		if yyct1687 == codecSelferValueTypeMap1234 {
			yyl1687 := r.ReadMapStart()
			if yyl1687 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1687, d)
			}
		} else if yyct1687 == codecSelferValueTypeArray1234 {
			yyl1687 := r.ReadArrayStart()
			if yyl1687 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1687, 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 yys1688Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1688Slc
	var yyhl1688 bool = l >= 0
	for yyj1688 := 0; ; yyj1688++ {
		if yyhl1688 {
			if yyj1688 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1688Slc = r.DecodeBytes(yys1688Slc, true, true)
		yys1688 := string(yys1688Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1688 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				x.PodSelector = LabelSelector{}
			} else {
				yyv1689 := &x.PodSelector
				yyv1689.CodecDecodeSelf(d)
			}
		case "ingress":
			if r.TryDecodeAsNil() {
				x.Ingress = nil
			} else {
				yyv1690 := &x.Ingress
				yym1691 := z.DecBinary()
				_ = yym1691
				if false {
				} else {
					h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1690), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1688)
		} // end switch yys1688
	} // end for yyj1688
	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 yyj1692 int
	var yyb1692 bool
	var yyhl1692 bool = l >= 0
	yyj1692++
	if yyhl1692 {
		yyb1692 = yyj1692 > l
	} else {
		yyb1692 = r.CheckBreak()
	}
	if yyb1692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PodSelector = LabelSelector{}
	} else {
		yyv1693 := &x.PodSelector
		yyv1693.CodecDecodeSelf(d)
	}
	yyj1692++
	if yyhl1692 {
		yyb1692 = yyj1692 > l
	} else {
		yyb1692 = r.CheckBreak()
	}
	if yyb1692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ingress = nil
	} else {
		yyv1694 := &x.Ingress
		yym1695 := z.DecBinary()
		_ = yym1695
		if false {
		} else {
			h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1694), d)
		}
	}
	for {
		yyj1692++
		if yyhl1692 {
			yyb1692 = yyj1692 > l
		} else {
			yyb1692 = r.CheckBreak()
		}
		if yyb1692 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1692-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 {
		yym1696 := z.EncBinary()
		_ = yym1696
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1697 := !z.EncBinary()
			yy2arr1697 := z.EncBasicHandle().StructToArray
			var yyq1697 [2]bool
			_, _, _ = yysep1697, yyq1697, yy2arr1697
			const yyr1697 bool = false
			yyq1697[0] = len(x.Ports) != 0
			yyq1697[1] = len(x.From) != 0
			var yynn1697 int
			if yyr1697 || yy2arr1697 {
				r.EncodeArrayStart(2)
			} else {
				yynn1697 = 0
				for _, b := range yyq1697 {
					if b {
						yynn1697++
					}
				}
				r.EncodeMapStart(yynn1697)
				yynn1697 = 0
			}
			if yyr1697 || yy2arr1697 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1697[0] {
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1699 := z.EncBinary()
						_ = yym1699
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1697[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ports"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1700 := z.EncBinary()
						_ = yym1700
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				}
			}
			if yyr1697 || yy2arr1697 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1697[1] {
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1702 := z.EncBinary()
						_ = yym1702
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1697[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("from"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1703 := z.EncBinary()
						_ = yym1703
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				}
			}
			if yyr1697 || yy2arr1697 {
				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
	yym1704 := z.DecBinary()
	_ = yym1704
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1705 := r.ContainerType()
		if yyct1705 == codecSelferValueTypeMap1234 {
			yyl1705 := r.ReadMapStart()
			if yyl1705 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1705, d)
			}
		} else if yyct1705 == codecSelferValueTypeArray1234 {
			yyl1705 := r.ReadArrayStart()
			if yyl1705 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1705, 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 yys1706Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1706Slc
	var yyhl1706 bool = l >= 0
	for yyj1706 := 0; ; yyj1706++ {
		if yyhl1706 {
			if yyj1706 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1706Slc = r.DecodeBytes(yys1706Slc, true, true)
		yys1706 := string(yys1706Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1706 {
		case "ports":
			if r.TryDecodeAsNil() {
				x.Ports = nil
			} else {
				yyv1707 := &x.Ports
				yym1708 := z.DecBinary()
				_ = yym1708
				if false {
				} else {
					h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1707), d)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv1709 := &x.From
				yym1710 := z.DecBinary()
				_ = yym1710
				if false {
				} else {
					h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1709), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1706)
		} // end switch yys1706
	} // end for yyj1706
	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 yyj1711 int
	var yyb1711 bool
	var yyhl1711 bool = l >= 0
	yyj1711++
	if yyhl1711 {
		yyb1711 = yyj1711 > l
	} else {
		yyb1711 = r.CheckBreak()
	}
	if yyb1711 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ports = nil
	} else {
		yyv1712 := &x.Ports
		yym1713 := z.DecBinary()
		_ = yym1713
		if false {
		} else {
			h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1712), d)
		}
	}
	yyj1711++
	if yyhl1711 {
		yyb1711 = yyj1711 > l
	} else {
		yyb1711 = r.CheckBreak()
	}
	if yyb1711 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv1714 := &x.From
		yym1715 := z.DecBinary()
		_ = yym1715
		if false {
		} else {
			h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1714), d)
		}
	}
	for {
		yyj1711++
		if yyhl1711 {
			yyb1711 = yyj1711 > l
		} else {
			yyb1711 = r.CheckBreak()
		}
		if yyb1711 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1711-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 {
		yym1716 := z.EncBinary()
		_ = yym1716
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1717 := !z.EncBinary()
			yy2arr1717 := z.EncBasicHandle().StructToArray
			var yyq1717 [2]bool
			_, _, _ = yysep1717, yyq1717, yy2arr1717
			const yyr1717 bool = false
			yyq1717[0] = x.Protocol != nil
			yyq1717[1] = x.Port != nil
			var yynn1717 int
			if yyr1717 || yy2arr1717 {
				r.EncodeArrayStart(2)
			} else {
				yynn1717 = 0
				for _, b := range yyq1717 {
					if b {
						yynn1717++
					}
				}
				r.EncodeMapStart(yynn1717)
				yynn1717 = 0
			}
			if yyr1717 || yy2arr1717 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1717[0] {
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1719 := *x.Protocol
						yym1720 := z.EncBinary()
						_ = yym1720
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1719) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1719))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1717[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("protocol"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1721 := *x.Protocol
						yym1722 := z.EncBinary()
						_ = yym1722
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1721) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1721))
						}
					}
				}
			}
			if yyr1717 || yy2arr1717 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1717[1] {
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1724 := z.EncBinary()
						_ = yym1724
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1724 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1717[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("port"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1725 := z.EncBinary()
						_ = yym1725
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1725 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				}
			}
			if yyr1717 || yy2arr1717 {
				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
	yym1726 := z.DecBinary()
	_ = yym1726
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1727 := r.ContainerType()
		if yyct1727 == codecSelferValueTypeMap1234 {
			yyl1727 := r.ReadMapStart()
			if yyl1727 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1727, d)
			}
		} else if yyct1727 == codecSelferValueTypeArray1234 {
			yyl1727 := r.ReadArrayStart()
			if yyl1727 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1727, 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 yys1728Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1728Slc
	var yyhl1728 bool = l >= 0
	for yyj1728 := 0; ; yyj1728++ {
		if yyhl1728 {
			if yyj1728 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1728Slc = r.DecodeBytes(yys1728Slc, true, true)
		yys1728 := string(yys1728Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1728 {
		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)
				}
				yym1731 := z.DecBinary()
				_ = yym1731
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Port) {
				} else if !yym1731 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Port)
				} else {
					z.DecFallback(x.Port, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1728)
		} // end switch yys1728
	} // end for yyj1728
	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 yyj1732 int
	var yyb1732 bool
	var yyhl1732 bool = l >= 0
	yyj1732++
	if yyhl1732 {
		yyb1732 = yyj1732 > l
	} else {
		yyb1732 = r.CheckBreak()
	}
	if yyb1732 {
		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)
	}
	yyj1732++
	if yyhl1732 {
		yyb1732 = yyj1732 > l
	} else {
		yyb1732 = r.CheckBreak()
	}
	if yyb1732 {
		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)
		}
		yym1735 := z.DecBinary()
		_ = yym1735
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Port) {
		} else if !yym1735 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Port)
		} else {
			z.DecFallback(x.Port, false)
		}
	}
	for {
		yyj1732++
		if yyhl1732 {
			yyb1732 = yyj1732 > l
		} else {
			yyb1732 = r.CheckBreak()
		}
		if yyb1732 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1732-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 {
		yym1736 := z.EncBinary()
		_ = yym1736
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1737 := !z.EncBinary()
			yy2arr1737 := z.EncBasicHandle().StructToArray
			var yyq1737 [2]bool
			_, _, _ = yysep1737, yyq1737, yy2arr1737
			const yyr1737 bool = false
			yyq1737[0] = x.PodSelector != nil
			yyq1737[1] = x.NamespaceSelector != nil
			var yynn1737 int
			if yyr1737 || yy2arr1737 {
				r.EncodeArrayStart(2)
			} else {
				yynn1737 = 0
				for _, b := range yyq1737 {
					if b {
						yynn1737++
					}
				}
				r.EncodeMapStart(yynn1737)
				yynn1737 = 0
			}
			if yyr1737 || yy2arr1737 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1737[0] {
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						x.PodSelector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1737[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 yyr1737 || yy2arr1737 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1737[1] {
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						x.NamespaceSelector.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1737[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 yyr1737 || yy2arr1737 {
				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
	yym1740 := z.DecBinary()
	_ = yym1740
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1741 := r.ContainerType()
		if yyct1741 == codecSelferValueTypeMap1234 {
			yyl1741 := r.ReadMapStart()
			if yyl1741 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1741, d)
			}
		} else if yyct1741 == codecSelferValueTypeArray1234 {
			yyl1741 := r.ReadArrayStart()
			if yyl1741 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1741, 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 yys1742Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1742Slc
	var yyhl1742 bool = l >= 0
	for yyj1742 := 0; ; yyj1742++ {
		if yyhl1742 {
			if yyj1742 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1742Slc = r.DecodeBytes(yys1742Slc, true, true)
		yys1742 := string(yys1742Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1742 {
		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, yys1742)
		} // end switch yys1742
	} // end for yyj1742
	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 yyj1745 int
	var yyb1745 bool
	var yyhl1745 bool = l >= 0
	yyj1745++
	if yyhl1745 {
		yyb1745 = yyj1745 > l
	} else {
		yyb1745 = r.CheckBreak()
	}
	if yyb1745 {
		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)
	}
	yyj1745++
	if yyhl1745 {
		yyb1745 = yyj1745 > l
	} else {
		yyb1745 = r.CheckBreak()
	}
	if yyb1745 {
		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 {
		yyj1745++
		if yyhl1745 {
			yyb1745 = yyj1745 > l
		} else {
			yyb1745 = r.CheckBreak()
		}
		if yyb1745 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1745-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 {
		yym1748 := z.EncBinary()
		_ = yym1748
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1749 := !z.EncBinary()
			yy2arr1749 := z.EncBasicHandle().StructToArray
			var yyq1749 [4]bool
			_, _, _ = yysep1749, yyq1749, yy2arr1749
			const yyr1749 bool = false
			yyq1749[0] = x.Kind != ""
			yyq1749[1] = x.APIVersion != ""
			yyq1749[2] = true
			var yynn1749 int
			if yyr1749 || yy2arr1749 {
				r.EncodeArrayStart(4)
			} else {
				yynn1749 = 1
				for _, b := range yyq1749 {
					if b {
						yynn1749++
					}
				}
				r.EncodeMapStart(yynn1749)
				yynn1749 = 0
			}
			if yyr1749 || yy2arr1749 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1749[0] {
					yym1751 := z.EncBinary()
					_ = yym1751
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1749[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1752 := z.EncBinary()
					_ = yym1752
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1749 || yy2arr1749 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1749[1] {
					yym1754 := z.EncBinary()
					_ = yym1754
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1749[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1755 := z.EncBinary()
					_ = yym1755
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1749 || yy2arr1749 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1749[2] {
					yy1757 := &x.ListMeta
					yym1758 := z.EncBinary()
					_ = yym1758
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1757) {
					} else {
						z.EncFallback(yy1757)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1749[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1759 := &x.ListMeta
					yym1760 := z.EncBinary()
					_ = yym1760
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1759) {
					} else {
						z.EncFallback(yy1759)
					}
				}
			}
			if yyr1749 || yy2arr1749 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1762 := z.EncBinary()
					_ = yym1762
					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 {
					yym1763 := z.EncBinary()
					_ = yym1763
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			}
			if yyr1749 || yy2arr1749 {
				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
	yym1764 := z.DecBinary()
	_ = yym1764
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1765 := r.ContainerType()
		if yyct1765 == codecSelferValueTypeMap1234 {
			yyl1765 := r.ReadMapStart()
			if yyl1765 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1765, d)
			}
		} else if yyct1765 == codecSelferValueTypeArray1234 {
			yyl1765 := r.ReadArrayStart()
			if yyl1765 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1765, 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 yys1766Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1766Slc
	var yyhl1766 bool = l >= 0
	for yyj1766 := 0; ; yyj1766++ {
		if yyhl1766 {
			if yyj1766 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1766Slc = r.DecodeBytes(yys1766Slc, true, true)
		yys1766 := string(yys1766Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1766 {
		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 {
				yyv1769 := &x.ListMeta
				yym1770 := z.DecBinary()
				_ = yym1770
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1769) {
				} else {
					z.DecFallback(yyv1769, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1771 := &x.Items
				yym1772 := z.DecBinary()
				_ = yym1772
				if false {
				} else {
					h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1771), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1766)
		} // end switch yys1766
	} // end for yyj1766
	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 yyj1773 int
	var yyb1773 bool
	var yyhl1773 bool = l >= 0
	yyj1773++
	if yyhl1773 {
		yyb1773 = yyj1773 > l
	} else {
		yyb1773 = r.CheckBreak()
	}
	if yyb1773 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1773++
	if yyhl1773 {
		yyb1773 = yyj1773 > l
	} else {
		yyb1773 = r.CheckBreak()
	}
	if yyb1773 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1773++
	if yyhl1773 {
		yyb1773 = yyj1773 > l
	} else {
		yyb1773 = r.CheckBreak()
	}
	if yyb1773 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1776 := &x.ListMeta
		yym1777 := z.DecBinary()
		_ = yym1777
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1776) {
		} else {
			z.DecFallback(yyv1776, false)
		}
	}
	yyj1773++
	if yyhl1773 {
		yyb1773 = yyj1773 > l
	} else {
		yyb1773 = r.CheckBreak()
	}
	if yyb1773 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1778 := &x.Items
		yym1779 := z.DecBinary()
		_ = yym1779
		if false {
		} else {
			h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1778), d)
		}
	}
	for {
		yyj1773++
		if yyhl1773 {
			yyb1773 = yyj1773 > l
		} else {
			yyb1773 = r.CheckBreak()
		}
		if yyb1773 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1773-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 _, yyv1780 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1781 := &yyv1780
		yy1781.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

	yyv1782 := *v
	yyh1782, yyl1782 := z.DecSliceHelperStart()
	var yyc1782 bool
	if yyl1782 == 0 {
		if yyv1782 == nil {
			yyv1782 = []CustomMetricTarget{}
			yyc1782 = true
		} else if len(yyv1782) != 0 {
			yyv1782 = yyv1782[:0]
			yyc1782 = true
		}
	} else if yyl1782 > 0 {
		var yyrr1782, yyrl1782 int
		var yyrt1782 bool
		if yyl1782 > cap(yyv1782) {

			yyrg1782 := len(yyv1782) > 0
			yyv21782 := yyv1782
			yyrl1782, yyrt1782 = z.DecInferLen(yyl1782, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1782 {
				if yyrl1782 <= cap(yyv1782) {
					yyv1782 = yyv1782[:yyrl1782]
				} else {
					yyv1782 = make([]CustomMetricTarget, yyrl1782)
				}
			} else {
				yyv1782 = make([]CustomMetricTarget, yyrl1782)
			}
			yyc1782 = true
			yyrr1782 = len(yyv1782)
			if yyrg1782 {
				copy(yyv1782, yyv21782)
			}
		} else if yyl1782 != len(yyv1782) {
			yyv1782 = yyv1782[:yyl1782]
			yyc1782 = true
		}
		yyj1782 := 0
		for ; yyj1782 < yyrr1782; yyj1782++ {
			yyh1782.ElemContainerState(yyj1782)
			if r.TryDecodeAsNil() {
				yyv1782[yyj1782] = CustomMetricTarget{}
			} else {
				yyv1783 := &yyv1782[yyj1782]
				yyv1783.CodecDecodeSelf(d)
			}

		}
		if yyrt1782 {
			for ; yyj1782 < yyl1782; yyj1782++ {
				yyv1782 = append(yyv1782, CustomMetricTarget{})
				yyh1782.ElemContainerState(yyj1782)
				if r.TryDecodeAsNil() {
					yyv1782[yyj1782] = CustomMetricTarget{}
				} else {
					yyv1784 := &yyv1782[yyj1782]
					yyv1784.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1782 >= len(yyv1782) {
				yyv1782 = append(yyv1782, CustomMetricTarget{}) // var yyz1782 CustomMetricTarget
				yyc1782 = true
			}
			yyh1782.ElemContainerState(yyj1782)
			if yyj1782 < len(yyv1782) {
				if r.TryDecodeAsNil() {
					yyv1782[yyj1782] = CustomMetricTarget{}
				} else {
					yyv1785 := &yyv1782[yyj1782]
					yyv1785.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1782 < len(yyv1782) {
			yyv1782 = yyv1782[:yyj1782]
			yyc1782 = true
		} else if yyj1782 == 0 && yyv1782 == nil {
			yyv1782 = []CustomMetricTarget{}
			yyc1782 = true
		}
	}
	yyh1782.End()
	if yyc1782 {
		*v = yyv1782
	}
}

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 _, yyv1786 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1787 := &yyv1786
		yy1787.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

	yyv1788 := *v
	yyh1788, yyl1788 := z.DecSliceHelperStart()
	var yyc1788 bool
	if yyl1788 == 0 {
		if yyv1788 == nil {
			yyv1788 = []CustomMetricCurrentStatus{}
			yyc1788 = true
		} else if len(yyv1788) != 0 {
			yyv1788 = yyv1788[:0]
			yyc1788 = true
		}
	} else if yyl1788 > 0 {
		var yyrr1788, yyrl1788 int
		var yyrt1788 bool
		if yyl1788 > cap(yyv1788) {

			yyrg1788 := len(yyv1788) > 0
			yyv21788 := yyv1788
			yyrl1788, yyrt1788 = z.DecInferLen(yyl1788, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1788 {
				if yyrl1788 <= cap(yyv1788) {
					yyv1788 = yyv1788[:yyrl1788]
				} else {
					yyv1788 = make([]CustomMetricCurrentStatus, yyrl1788)
				}
			} else {
				yyv1788 = make([]CustomMetricCurrentStatus, yyrl1788)
			}
			yyc1788 = true
			yyrr1788 = len(yyv1788)
			if yyrg1788 {
				copy(yyv1788, yyv21788)
			}
		} else if yyl1788 != len(yyv1788) {
			yyv1788 = yyv1788[:yyl1788]
			yyc1788 = true
		}
		yyj1788 := 0
		for ; yyj1788 < yyrr1788; yyj1788++ {
			yyh1788.ElemContainerState(yyj1788)
			if r.TryDecodeAsNil() {
				yyv1788[yyj1788] = CustomMetricCurrentStatus{}
			} else {
				yyv1789 := &yyv1788[yyj1788]
				yyv1789.CodecDecodeSelf(d)
			}

		}
		if yyrt1788 {
			for ; yyj1788 < yyl1788; yyj1788++ {
				yyv1788 = append(yyv1788, CustomMetricCurrentStatus{})
				yyh1788.ElemContainerState(yyj1788)
				if r.TryDecodeAsNil() {
					yyv1788[yyj1788] = CustomMetricCurrentStatus{}
				} else {
					yyv1790 := &yyv1788[yyj1788]
					yyv1790.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1788 >= len(yyv1788) {
				yyv1788 = append(yyv1788, CustomMetricCurrentStatus{}) // var yyz1788 CustomMetricCurrentStatus
				yyc1788 = true
			}
			yyh1788.ElemContainerState(yyj1788)
			if yyj1788 < len(yyv1788) {
				if r.TryDecodeAsNil() {
					yyv1788[yyj1788] = CustomMetricCurrentStatus{}
				} else {
					yyv1791 := &yyv1788[yyj1788]
					yyv1791.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1788 < len(yyv1788) {
			yyv1788 = yyv1788[:yyj1788]
			yyc1788 = true
		} else if yyj1788 == 0 && yyv1788 == nil {
			yyv1788 = []CustomMetricCurrentStatus{}
			yyc1788 = true
		}
	}
	yyh1788.End()
	if yyc1788 {
		*v = yyv1788
	}
}

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 _, yyv1792 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1793 := &yyv1792
		yy1793.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

	yyv1794 := *v
	yyh1794, yyl1794 := z.DecSliceHelperStart()
	var yyc1794 bool
	if yyl1794 == 0 {
		if yyv1794 == nil {
			yyv1794 = []HorizontalPodAutoscaler{}
			yyc1794 = true
		} else if len(yyv1794) != 0 {
			yyv1794 = yyv1794[:0]
			yyc1794 = true
		}
	} else if yyl1794 > 0 {
		var yyrr1794, yyrl1794 int
		var yyrt1794 bool
		if yyl1794 > cap(yyv1794) {

			yyrg1794 := len(yyv1794) > 0
			yyv21794 := yyv1794
			yyrl1794, yyrt1794 = z.DecInferLen(yyl1794, z.DecBasicHandle().MaxInitLen, 376)
			if yyrt1794 {
				if yyrl1794 <= cap(yyv1794) {
					yyv1794 = yyv1794[:yyrl1794]
				} else {
					yyv1794 = make([]HorizontalPodAutoscaler, yyrl1794)
				}
			} else {
				yyv1794 = make([]HorizontalPodAutoscaler, yyrl1794)
			}
			yyc1794 = true
			yyrr1794 = len(yyv1794)
			if yyrg1794 {
				copy(yyv1794, yyv21794)
			}
		} else if yyl1794 != len(yyv1794) {
			yyv1794 = yyv1794[:yyl1794]
			yyc1794 = true
		}
		yyj1794 := 0
		for ; yyj1794 < yyrr1794; yyj1794++ {
			yyh1794.ElemContainerState(yyj1794)
			if r.TryDecodeAsNil() {
				yyv1794[yyj1794] = HorizontalPodAutoscaler{}
			} else {
				yyv1795 := &yyv1794[yyj1794]
				yyv1795.CodecDecodeSelf(d)
			}

		}
		if yyrt1794 {
			for ; yyj1794 < yyl1794; yyj1794++ {
				yyv1794 = append(yyv1794, HorizontalPodAutoscaler{})
				yyh1794.ElemContainerState(yyj1794)
				if r.TryDecodeAsNil() {
					yyv1794[yyj1794] = HorizontalPodAutoscaler{}
				} else {
					yyv1796 := &yyv1794[yyj1794]
					yyv1796.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1794 >= len(yyv1794) {
				yyv1794 = append(yyv1794, HorizontalPodAutoscaler{}) // var yyz1794 HorizontalPodAutoscaler
				yyc1794 = true
			}
			yyh1794.ElemContainerState(yyj1794)
			if yyj1794 < len(yyv1794) {
				if r.TryDecodeAsNil() {
					yyv1794[yyj1794] = HorizontalPodAutoscaler{}
				} else {
					yyv1797 := &yyv1794[yyj1794]
					yyv1797.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1794 < len(yyv1794) {
			yyv1794 = yyv1794[:yyj1794]
			yyc1794 = true
		} else if yyj1794 == 0 && yyv1794 == nil {
			yyv1794 = []HorizontalPodAutoscaler{}
			yyc1794 = true
		}
	}
	yyh1794.End()
	if yyc1794 {
		*v = yyv1794
	}
}

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 _, yyv1798 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1799 := &yyv1798
		yy1799.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

	yyv1800 := *v
	yyh1800, yyl1800 := z.DecSliceHelperStart()
	var yyc1800 bool
	if yyl1800 == 0 {
		if yyv1800 == nil {
			yyv1800 = []APIVersion{}
			yyc1800 = true
		} else if len(yyv1800) != 0 {
			yyv1800 = yyv1800[:0]
			yyc1800 = true
		}
	} else if yyl1800 > 0 {
		var yyrr1800, yyrl1800 int
		var yyrt1800 bool
		if yyl1800 > cap(yyv1800) {

			yyrg1800 := len(yyv1800) > 0
			yyv21800 := yyv1800
			yyrl1800, yyrt1800 = z.DecInferLen(yyl1800, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1800 {
				if yyrl1800 <= cap(yyv1800) {
					yyv1800 = yyv1800[:yyrl1800]
				} else {
					yyv1800 = make([]APIVersion, yyrl1800)
				}
			} else {
				yyv1800 = make([]APIVersion, yyrl1800)
			}
			yyc1800 = true
			yyrr1800 = len(yyv1800)
			if yyrg1800 {
				copy(yyv1800, yyv21800)
			}
		} else if yyl1800 != len(yyv1800) {
			yyv1800 = yyv1800[:yyl1800]
			yyc1800 = true
		}
		yyj1800 := 0
		for ; yyj1800 < yyrr1800; yyj1800++ {
			yyh1800.ElemContainerState(yyj1800)
			if r.TryDecodeAsNil() {
				yyv1800[yyj1800] = APIVersion{}
			} else {
				yyv1801 := &yyv1800[yyj1800]
				yyv1801.CodecDecodeSelf(d)
			}

		}
		if yyrt1800 {
			for ; yyj1800 < yyl1800; yyj1800++ {
				yyv1800 = append(yyv1800, APIVersion{})
				yyh1800.ElemContainerState(yyj1800)
				if r.TryDecodeAsNil() {
					yyv1800[yyj1800] = APIVersion{}
				} else {
					yyv1802 := &yyv1800[yyj1800]
					yyv1802.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1800 >= len(yyv1800) {
				yyv1800 = append(yyv1800, APIVersion{}) // var yyz1800 APIVersion
				yyc1800 = true
			}
			yyh1800.ElemContainerState(yyj1800)
			if yyj1800 < len(yyv1800) {
				if r.TryDecodeAsNil() {
					yyv1800[yyj1800] = APIVersion{}
				} else {
					yyv1803 := &yyv1800[yyj1800]
					yyv1803.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1800 < len(yyv1800) {
			yyv1800 = yyv1800[:yyj1800]
			yyc1800 = true
		} else if yyj1800 == 0 && yyv1800 == nil {
			yyv1800 = []APIVersion{}
			yyc1800 = true
		}
	}
	yyh1800.End()
	if yyc1800 {
		*v = yyv1800
	}
}

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 _, yyv1804 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1805 := &yyv1804
		yy1805.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

	yyv1806 := *v
	yyh1806, yyl1806 := z.DecSliceHelperStart()
	var yyc1806 bool
	if yyl1806 == 0 {
		if yyv1806 == nil {
			yyv1806 = []ThirdPartyResource{}
			yyc1806 = true
		} else if len(yyv1806) != 0 {
			yyv1806 = yyv1806[:0]
			yyc1806 = true
		}
	} else if yyl1806 > 0 {
		var yyrr1806, yyrl1806 int
		var yyrt1806 bool
		if yyl1806 > cap(yyv1806) {

			yyrg1806 := len(yyv1806) > 0
			yyv21806 := yyv1806
			yyrl1806, yyrt1806 = z.DecInferLen(yyl1806, z.DecBasicHandle().MaxInitLen, 296)
			if yyrt1806 {
				if yyrl1806 <= cap(yyv1806) {
					yyv1806 = yyv1806[:yyrl1806]
				} else {
					yyv1806 = make([]ThirdPartyResource, yyrl1806)
				}
			} else {
				yyv1806 = make([]ThirdPartyResource, yyrl1806)
			}
			yyc1806 = true
			yyrr1806 = len(yyv1806)
			if yyrg1806 {
				copy(yyv1806, yyv21806)
			}
		} else if yyl1806 != len(yyv1806) {
			yyv1806 = yyv1806[:yyl1806]
			yyc1806 = true
		}
		yyj1806 := 0
		for ; yyj1806 < yyrr1806; yyj1806++ {
			yyh1806.ElemContainerState(yyj1806)
			if r.TryDecodeAsNil() {
				yyv1806[yyj1806] = ThirdPartyResource{}
			} else {
				yyv1807 := &yyv1806[yyj1806]
				yyv1807.CodecDecodeSelf(d)
			}

		}
		if yyrt1806 {
			for ; yyj1806 < yyl1806; yyj1806++ {
				yyv1806 = append(yyv1806, ThirdPartyResource{})
				yyh1806.ElemContainerState(yyj1806)
				if r.TryDecodeAsNil() {
					yyv1806[yyj1806] = ThirdPartyResource{}
				} else {
					yyv1808 := &yyv1806[yyj1806]
					yyv1808.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1806 >= len(yyv1806) {
				yyv1806 = append(yyv1806, ThirdPartyResource{}) // var yyz1806 ThirdPartyResource
				yyc1806 = true
			}
			yyh1806.ElemContainerState(yyj1806)
			if yyj1806 < len(yyv1806) {
				if r.TryDecodeAsNil() {
					yyv1806[yyj1806] = ThirdPartyResource{}
				} else {
					yyv1809 := &yyv1806[yyj1806]
					yyv1809.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1806 < len(yyv1806) {
			yyv1806 = yyv1806[:yyj1806]
			yyc1806 = true
		} else if yyj1806 == 0 && yyv1806 == nil {
			yyv1806 = []ThirdPartyResource{}
			yyc1806 = true
		}
	}
	yyh1806.End()
	if yyc1806 {
		*v = yyv1806
	}
}

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 _, yyv1810 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1811 := &yyv1810
		yy1811.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

	yyv1812 := *v
	yyh1812, yyl1812 := z.DecSliceHelperStart()
	var yyc1812 bool
	if yyl1812 == 0 {
		if yyv1812 == nil {
			yyv1812 = []Deployment{}
			yyc1812 = true
		} else if len(yyv1812) != 0 {
			yyv1812 = yyv1812[:0]
			yyc1812 = true
		}
	} else if yyl1812 > 0 {
		var yyrr1812, yyrl1812 int
		var yyrt1812 bool
		if yyl1812 > cap(yyv1812) {

			yyrg1812 := len(yyv1812) > 0
			yyv21812 := yyv1812
			yyrl1812, yyrt1812 = z.DecInferLen(yyl1812, z.DecBasicHandle().MaxInitLen, 824)
			if yyrt1812 {
				if yyrl1812 <= cap(yyv1812) {
					yyv1812 = yyv1812[:yyrl1812]
				} else {
					yyv1812 = make([]Deployment, yyrl1812)
				}
			} else {
				yyv1812 = make([]Deployment, yyrl1812)
			}
			yyc1812 = true
			yyrr1812 = len(yyv1812)
			if yyrg1812 {
				copy(yyv1812, yyv21812)
			}
		} else if yyl1812 != len(yyv1812) {
			yyv1812 = yyv1812[:yyl1812]
			yyc1812 = true
		}
		yyj1812 := 0
		for ; yyj1812 < yyrr1812; yyj1812++ {
			yyh1812.ElemContainerState(yyj1812)
			if r.TryDecodeAsNil() {
				yyv1812[yyj1812] = Deployment{}
			} else {
				yyv1813 := &yyv1812[yyj1812]
				yyv1813.CodecDecodeSelf(d)
			}

		}
		if yyrt1812 {
			for ; yyj1812 < yyl1812; yyj1812++ {
				yyv1812 = append(yyv1812, Deployment{})
				yyh1812.ElemContainerState(yyj1812)
				if r.TryDecodeAsNil() {
					yyv1812[yyj1812] = Deployment{}
				} else {
					yyv1814 := &yyv1812[yyj1812]
					yyv1814.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1812 >= len(yyv1812) {
				yyv1812 = append(yyv1812, Deployment{}) // var yyz1812 Deployment
				yyc1812 = true
			}
			yyh1812.ElemContainerState(yyj1812)
			if yyj1812 < len(yyv1812) {
				if r.TryDecodeAsNil() {
					yyv1812[yyj1812] = Deployment{}
				} else {
					yyv1815 := &yyv1812[yyj1812]
					yyv1815.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1812 < len(yyv1812) {
			yyv1812 = yyv1812[:yyj1812]
			yyc1812 = true
		} else if yyj1812 == 0 && yyv1812 == nil {
			yyv1812 = []Deployment{}
			yyc1812 = true
		}
	}
	yyh1812.End()
	if yyc1812 {
		*v = yyv1812
	}
}

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 _, yyv1816 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1817 := &yyv1816
		yy1817.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

	yyv1818 := *v
	yyh1818, yyl1818 := z.DecSliceHelperStart()
	var yyc1818 bool
	if yyl1818 == 0 {
		if yyv1818 == nil {
			yyv1818 = []DaemonSet{}
			yyc1818 = true
		} else if len(yyv1818) != 0 {
			yyv1818 = yyv1818[:0]
			yyc1818 = true
		}
	} else if yyl1818 > 0 {
		var yyrr1818, yyrl1818 int
		var yyrt1818 bool
		if yyl1818 > cap(yyv1818) {

			yyrg1818 := len(yyv1818) > 0
			yyv21818 := yyv1818
			yyrl1818, yyrt1818 = z.DecInferLen(yyl1818, z.DecBasicHandle().MaxInitLen, 752)
			if yyrt1818 {
				if yyrl1818 <= cap(yyv1818) {
					yyv1818 = yyv1818[:yyrl1818]
				} else {
					yyv1818 = make([]DaemonSet, yyrl1818)
				}
			} else {
				yyv1818 = make([]DaemonSet, yyrl1818)
			}
			yyc1818 = true
			yyrr1818 = len(yyv1818)
			if yyrg1818 {
				copy(yyv1818, yyv21818)
			}
		} else if yyl1818 != len(yyv1818) {
			yyv1818 = yyv1818[:yyl1818]
			yyc1818 = true
		}
		yyj1818 := 0
		for ; yyj1818 < yyrr1818; yyj1818++ {
			yyh1818.ElemContainerState(yyj1818)
			if r.TryDecodeAsNil() {
				yyv1818[yyj1818] = DaemonSet{}
			} else {
				yyv1819 := &yyv1818[yyj1818]
				yyv1819.CodecDecodeSelf(d)
			}

		}
		if yyrt1818 {
			for ; yyj1818 < yyl1818; yyj1818++ {
				yyv1818 = append(yyv1818, DaemonSet{})
				yyh1818.ElemContainerState(yyj1818)
				if r.TryDecodeAsNil() {
					yyv1818[yyj1818] = DaemonSet{}
				} else {
					yyv1820 := &yyv1818[yyj1818]
					yyv1820.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1818 >= len(yyv1818) {
				yyv1818 = append(yyv1818, DaemonSet{}) // var yyz1818 DaemonSet
				yyc1818 = true
			}
			yyh1818.ElemContainerState(yyj1818)
			if yyj1818 < len(yyv1818) {
				if r.TryDecodeAsNil() {
					yyv1818[yyj1818] = DaemonSet{}
				} else {
					yyv1821 := &yyv1818[yyj1818]
					yyv1821.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1818 < len(yyv1818) {
			yyv1818 = yyv1818[:yyj1818]
			yyc1818 = true
		} else if yyj1818 == 0 && yyv1818 == nil {
			yyv1818 = []DaemonSet{}
			yyc1818 = true
		}
	}
	yyh1818.End()
	if yyc1818 {
		*v = yyv1818
	}
}

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 _, yyv1822 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1823 := &yyv1822
		yy1823.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

	yyv1824 := *v
	yyh1824, yyl1824 := z.DecSliceHelperStart()
	var yyc1824 bool
	if yyl1824 == 0 {
		if yyv1824 == nil {
			yyv1824 = []ThirdPartyResourceData{}
			yyc1824 = true
		} else if len(yyv1824) != 0 {
			yyv1824 = yyv1824[:0]
			yyc1824 = true
		}
	} else if yyl1824 > 0 {
		var yyrr1824, yyrl1824 int
		var yyrt1824 bool
		if yyl1824 > cap(yyv1824) {

			yyrg1824 := len(yyv1824) > 0
			yyv21824 := yyv1824
			yyrl1824, yyrt1824 = z.DecInferLen(yyl1824, z.DecBasicHandle().MaxInitLen, 280)
			if yyrt1824 {
				if yyrl1824 <= cap(yyv1824) {
					yyv1824 = yyv1824[:yyrl1824]
				} else {
					yyv1824 = make([]ThirdPartyResourceData, yyrl1824)
				}
			} else {
				yyv1824 = make([]ThirdPartyResourceData, yyrl1824)
			}
			yyc1824 = true
			yyrr1824 = len(yyv1824)
			if yyrg1824 {
				copy(yyv1824, yyv21824)
			}
		} else if yyl1824 != len(yyv1824) {
			yyv1824 = yyv1824[:yyl1824]
			yyc1824 = true
		}
		yyj1824 := 0
		for ; yyj1824 < yyrr1824; yyj1824++ {
			yyh1824.ElemContainerState(yyj1824)
			if r.TryDecodeAsNil() {
				yyv1824[yyj1824] = ThirdPartyResourceData{}
			} else {
				yyv1825 := &yyv1824[yyj1824]
				yyv1825.CodecDecodeSelf(d)
			}

		}
		if yyrt1824 {
			for ; yyj1824 < yyl1824; yyj1824++ {
				yyv1824 = append(yyv1824, ThirdPartyResourceData{})
				yyh1824.ElemContainerState(yyj1824)
				if r.TryDecodeAsNil() {
					yyv1824[yyj1824] = ThirdPartyResourceData{}
				} else {
					yyv1826 := &yyv1824[yyj1824]
					yyv1826.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1824 >= len(yyv1824) {
				yyv1824 = append(yyv1824, ThirdPartyResourceData{}) // var yyz1824 ThirdPartyResourceData
				yyc1824 = true
			}
			yyh1824.ElemContainerState(yyj1824)
			if yyj1824 < len(yyv1824) {
				if r.TryDecodeAsNil() {
					yyv1824[yyj1824] = ThirdPartyResourceData{}
				} else {
					yyv1827 := &yyv1824[yyj1824]
					yyv1827.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1824 < len(yyv1824) {
			yyv1824 = yyv1824[:yyj1824]
			yyc1824 = true
		} else if yyj1824 == 0 && yyv1824 == nil {
			yyv1824 = []ThirdPartyResourceData{}
			yyc1824 = true
		}
	}
	yyh1824.End()
	if yyc1824 {
		*v = yyv1824
	}
}

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 _, yyv1828 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1829 := &yyv1828
		yy1829.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

	yyv1830 := *v
	yyh1830, yyl1830 := z.DecSliceHelperStart()
	var yyc1830 bool
	if yyl1830 == 0 {
		if yyv1830 == nil {
			yyv1830 = []Job{}
			yyc1830 = true
		} else if len(yyv1830) != 0 {
			yyv1830 = yyv1830[:0]
			yyc1830 = true
		}
	} else if yyl1830 > 0 {
		var yyrr1830, yyrl1830 int
		var yyrt1830 bool
		if yyl1830 > cap(yyv1830) {

			yyrg1830 := len(yyv1830) > 0
			yyv21830 := yyv1830
			yyrl1830, yyrt1830 = z.DecInferLen(yyl1830, z.DecBasicHandle().MaxInitLen, 824)
			if yyrt1830 {
				if yyrl1830 <= cap(yyv1830) {
					yyv1830 = yyv1830[:yyrl1830]
				} else {
					yyv1830 = make([]Job, yyrl1830)
				}
			} else {
				yyv1830 = make([]Job, yyrl1830)
			}
			yyc1830 = true
			yyrr1830 = len(yyv1830)
			if yyrg1830 {
				copy(yyv1830, yyv21830)
			}
		} else if yyl1830 != len(yyv1830) {
			yyv1830 = yyv1830[:yyl1830]
			yyc1830 = true
		}
		yyj1830 := 0
		for ; yyj1830 < yyrr1830; yyj1830++ {
			yyh1830.ElemContainerState(yyj1830)
			if r.TryDecodeAsNil() {
				yyv1830[yyj1830] = Job{}
			} else {
				yyv1831 := &yyv1830[yyj1830]
				yyv1831.CodecDecodeSelf(d)
			}

		}
		if yyrt1830 {
			for ; yyj1830 < yyl1830; yyj1830++ {
				yyv1830 = append(yyv1830, Job{})
				yyh1830.ElemContainerState(yyj1830)
				if r.TryDecodeAsNil() {
					yyv1830[yyj1830] = Job{}
				} else {
					yyv1832 := &yyv1830[yyj1830]
					yyv1832.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1830 >= len(yyv1830) {
				yyv1830 = append(yyv1830, Job{}) // var yyz1830 Job
				yyc1830 = true
			}
			yyh1830.ElemContainerState(yyj1830)
			if yyj1830 < len(yyv1830) {
				if r.TryDecodeAsNil() {
					yyv1830[yyj1830] = Job{}
				} else {
					yyv1833 := &yyv1830[yyj1830]
					yyv1833.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1830 < len(yyv1830) {
			yyv1830 = yyv1830[:yyj1830]
			yyc1830 = true
		} else if yyj1830 == 0 && yyv1830 == nil {
			yyv1830 = []Job{}
			yyc1830 = true
		}
	}
	yyh1830.End()
	if yyc1830 {
		*v = yyv1830
	}
}

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 _, yyv1834 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1835 := &yyv1834
		yy1835.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

	yyv1836 := *v
	yyh1836, yyl1836 := z.DecSliceHelperStart()
	var yyc1836 bool
	if yyl1836 == 0 {
		if yyv1836 == nil {
			yyv1836 = []JobCondition{}
			yyc1836 = true
		} else if len(yyv1836) != 0 {
			yyv1836 = yyv1836[:0]
			yyc1836 = true
		}
	} else if yyl1836 > 0 {
		var yyrr1836, yyrl1836 int
		var yyrt1836 bool
		if yyl1836 > cap(yyv1836) {

			yyrg1836 := len(yyv1836) > 0
			yyv21836 := yyv1836
			yyrl1836, yyrt1836 = z.DecInferLen(yyl1836, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1836 {
				if yyrl1836 <= cap(yyv1836) {
					yyv1836 = yyv1836[:yyrl1836]
				} else {
					yyv1836 = make([]JobCondition, yyrl1836)
				}
			} else {
				yyv1836 = make([]JobCondition, yyrl1836)
			}
			yyc1836 = true
			yyrr1836 = len(yyv1836)
			if yyrg1836 {
				copy(yyv1836, yyv21836)
			}
		} else if yyl1836 != len(yyv1836) {
			yyv1836 = yyv1836[:yyl1836]
			yyc1836 = true
		}
		yyj1836 := 0
		for ; yyj1836 < yyrr1836; yyj1836++ {
			yyh1836.ElemContainerState(yyj1836)
			if r.TryDecodeAsNil() {
				yyv1836[yyj1836] = JobCondition{}
			} else {
				yyv1837 := &yyv1836[yyj1836]
				yyv1837.CodecDecodeSelf(d)
			}

		}
		if yyrt1836 {
			for ; yyj1836 < yyl1836; yyj1836++ {
				yyv1836 = append(yyv1836, JobCondition{})
				yyh1836.ElemContainerState(yyj1836)
				if r.TryDecodeAsNil() {
					yyv1836[yyj1836] = JobCondition{}
				} else {
					yyv1838 := &yyv1836[yyj1836]
					yyv1838.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1836 >= len(yyv1836) {
				yyv1836 = append(yyv1836, JobCondition{}) // var yyz1836 JobCondition
				yyc1836 = true
			}
			yyh1836.ElemContainerState(yyj1836)
			if yyj1836 < len(yyv1836) {
				if r.TryDecodeAsNil() {
					yyv1836[yyj1836] = JobCondition{}
				} else {
					yyv1839 := &yyv1836[yyj1836]
					yyv1839.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1836 < len(yyv1836) {
			yyv1836 = yyv1836[:yyj1836]
			yyc1836 = true
		} else if yyj1836 == 0 && yyv1836 == nil {
			yyv1836 = []JobCondition{}
			yyc1836 = true
		}
	}
	yyh1836.End()
	if yyc1836 {
		*v = yyv1836
	}
}

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 _, yyv1840 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1841 := &yyv1840
		yy1841.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

	yyv1842 := *v
	yyh1842, yyl1842 := z.DecSliceHelperStart()
	var yyc1842 bool
	if yyl1842 == 0 {
		if yyv1842 == nil {
			yyv1842 = []Ingress{}
			yyc1842 = true
		} else if len(yyv1842) != 0 {
			yyv1842 = yyv1842[:0]
			yyc1842 = true
		}
	} else if yyl1842 > 0 {
		var yyrr1842, yyrl1842 int
		var yyrt1842 bool
		if yyl1842 > cap(yyv1842) {

			yyrg1842 := len(yyv1842) > 0
			yyv21842 := yyv1842
			yyrl1842, yyrt1842 = z.DecInferLen(yyl1842, z.DecBasicHandle().MaxInitLen, 336)
			if yyrt1842 {
				if yyrl1842 <= cap(yyv1842) {
					yyv1842 = yyv1842[:yyrl1842]
				} else {
					yyv1842 = make([]Ingress, yyrl1842)
				}
			} else {
				yyv1842 = make([]Ingress, yyrl1842)
			}
			yyc1842 = true
			yyrr1842 = len(yyv1842)
			if yyrg1842 {
				copy(yyv1842, yyv21842)
			}
		} else if yyl1842 != len(yyv1842) {
			yyv1842 = yyv1842[:yyl1842]
			yyc1842 = true
		}
		yyj1842 := 0
		for ; yyj1842 < yyrr1842; yyj1842++ {
			yyh1842.ElemContainerState(yyj1842)
			if r.TryDecodeAsNil() {
				yyv1842[yyj1842] = Ingress{}
			} else {
				yyv1843 := &yyv1842[yyj1842]
				yyv1843.CodecDecodeSelf(d)
			}

		}
		if yyrt1842 {
			for ; yyj1842 < yyl1842; yyj1842++ {
				yyv1842 = append(yyv1842, Ingress{})
				yyh1842.ElemContainerState(yyj1842)
				if r.TryDecodeAsNil() {
					yyv1842[yyj1842] = Ingress{}
				} else {
					yyv1844 := &yyv1842[yyj1842]
					yyv1844.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1842 >= len(yyv1842) {
				yyv1842 = append(yyv1842, Ingress{}) // var yyz1842 Ingress
				yyc1842 = true
			}
			yyh1842.ElemContainerState(yyj1842)
			if yyj1842 < len(yyv1842) {
				if r.TryDecodeAsNil() {
					yyv1842[yyj1842] = Ingress{}
				} else {
					yyv1845 := &yyv1842[yyj1842]
					yyv1845.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1842 < len(yyv1842) {
			yyv1842 = yyv1842[:yyj1842]
			yyc1842 = true
		} else if yyj1842 == 0 && yyv1842 == nil {
			yyv1842 = []Ingress{}
			yyc1842 = true
		}
	}
	yyh1842.End()
	if yyc1842 {
		*v = yyv1842
	}
}

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 _, yyv1846 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1847 := &yyv1846
		yy1847.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

	yyv1848 := *v
	yyh1848, yyl1848 := z.DecSliceHelperStart()
	var yyc1848 bool
	if yyl1848 == 0 {
		if yyv1848 == nil {
			yyv1848 = []IngressTLS{}
			yyc1848 = true
		} else if len(yyv1848) != 0 {
			yyv1848 = yyv1848[:0]
			yyc1848 = true
		}
	} else if yyl1848 > 0 {
		var yyrr1848, yyrl1848 int
		var yyrt1848 bool
		if yyl1848 > cap(yyv1848) {

			yyrg1848 := len(yyv1848) > 0
			yyv21848 := yyv1848
			yyrl1848, yyrt1848 = z.DecInferLen(yyl1848, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1848 {
				if yyrl1848 <= cap(yyv1848) {
					yyv1848 = yyv1848[:yyrl1848]
				} else {
					yyv1848 = make([]IngressTLS, yyrl1848)
				}
			} else {
				yyv1848 = make([]IngressTLS, yyrl1848)
			}
			yyc1848 = true
			yyrr1848 = len(yyv1848)
			if yyrg1848 {
				copy(yyv1848, yyv21848)
			}
		} else if yyl1848 != len(yyv1848) {
			yyv1848 = yyv1848[:yyl1848]
			yyc1848 = true
		}
		yyj1848 := 0
		for ; yyj1848 < yyrr1848; yyj1848++ {
			yyh1848.ElemContainerState(yyj1848)
			if r.TryDecodeAsNil() {
				yyv1848[yyj1848] = IngressTLS{}
			} else {
				yyv1849 := &yyv1848[yyj1848]
				yyv1849.CodecDecodeSelf(d)
			}

		}
		if yyrt1848 {
			for ; yyj1848 < yyl1848; yyj1848++ {
				yyv1848 = append(yyv1848, IngressTLS{})
				yyh1848.ElemContainerState(yyj1848)
				if r.TryDecodeAsNil() {
					yyv1848[yyj1848] = IngressTLS{}
				} else {
					yyv1850 := &yyv1848[yyj1848]
					yyv1850.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1848 >= len(yyv1848) {
				yyv1848 = append(yyv1848, IngressTLS{}) // var yyz1848 IngressTLS
				yyc1848 = true
			}
			yyh1848.ElemContainerState(yyj1848)
			if yyj1848 < len(yyv1848) {
				if r.TryDecodeAsNil() {
					yyv1848[yyj1848] = IngressTLS{}
				} else {
					yyv1851 := &yyv1848[yyj1848]
					yyv1851.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1848 < len(yyv1848) {
			yyv1848 = yyv1848[:yyj1848]
			yyc1848 = true
		} else if yyj1848 == 0 && yyv1848 == nil {
			yyv1848 = []IngressTLS{}
			yyc1848 = true
		}
	}
	yyh1848.End()
	if yyc1848 {
		*v = yyv1848
	}
}

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 _, yyv1852 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1853 := &yyv1852
		yy1853.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

	yyv1854 := *v
	yyh1854, yyl1854 := z.DecSliceHelperStart()
	var yyc1854 bool
	if yyl1854 == 0 {
		if yyv1854 == nil {
			yyv1854 = []IngressRule{}
			yyc1854 = true
		} else if len(yyv1854) != 0 {
			yyv1854 = yyv1854[:0]
			yyc1854 = true
		}
	} else if yyl1854 > 0 {
		var yyrr1854, yyrl1854 int
		var yyrt1854 bool
		if yyl1854 > cap(yyv1854) {

			yyrg1854 := len(yyv1854) > 0
			yyv21854 := yyv1854
			yyrl1854, yyrt1854 = z.DecInferLen(yyl1854, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1854 {
				if yyrl1854 <= cap(yyv1854) {
					yyv1854 = yyv1854[:yyrl1854]
				} else {
					yyv1854 = make([]IngressRule, yyrl1854)
				}
			} else {
				yyv1854 = make([]IngressRule, yyrl1854)
			}
			yyc1854 = true
			yyrr1854 = len(yyv1854)
			if yyrg1854 {
				copy(yyv1854, yyv21854)
			}
		} else if yyl1854 != len(yyv1854) {
			yyv1854 = yyv1854[:yyl1854]
			yyc1854 = true
		}
		yyj1854 := 0
		for ; yyj1854 < yyrr1854; yyj1854++ {
			yyh1854.ElemContainerState(yyj1854)
			if r.TryDecodeAsNil() {
				yyv1854[yyj1854] = IngressRule{}
			} else {
				yyv1855 := &yyv1854[yyj1854]
				yyv1855.CodecDecodeSelf(d)
			}

		}
		if yyrt1854 {
			for ; yyj1854 < yyl1854; yyj1854++ {
				yyv1854 = append(yyv1854, IngressRule{})
				yyh1854.ElemContainerState(yyj1854)
				if r.TryDecodeAsNil() {
					yyv1854[yyj1854] = IngressRule{}
				} else {
					yyv1856 := &yyv1854[yyj1854]
					yyv1856.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1854 >= len(yyv1854) {
				yyv1854 = append(yyv1854, IngressRule{}) // var yyz1854 IngressRule
				yyc1854 = true
			}
			yyh1854.ElemContainerState(yyj1854)
			if yyj1854 < len(yyv1854) {
				if r.TryDecodeAsNil() {
					yyv1854[yyj1854] = IngressRule{}
				} else {
					yyv1857 := &yyv1854[yyj1854]
					yyv1857.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1854 < len(yyv1854) {
			yyv1854 = yyv1854[:yyj1854]
			yyc1854 = true
		} else if yyj1854 == 0 && yyv1854 == nil {
			yyv1854 = []IngressRule{}
			yyc1854 = true
		}
	}
	yyh1854.End()
	if yyc1854 {
		*v = yyv1854
	}
}

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 _, yyv1858 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1859 := &yyv1858
		yy1859.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

	yyv1860 := *v
	yyh1860, yyl1860 := z.DecSliceHelperStart()
	var yyc1860 bool
	if yyl1860 == 0 {
		if yyv1860 == nil {
			yyv1860 = []HTTPIngressPath{}
			yyc1860 = true
		} else if len(yyv1860) != 0 {
			yyv1860 = yyv1860[:0]
			yyc1860 = true
		}
	} else if yyl1860 > 0 {
		var yyrr1860, yyrl1860 int
		var yyrt1860 bool
		if yyl1860 > cap(yyv1860) {

			yyrg1860 := len(yyv1860) > 0
			yyv21860 := yyv1860
			yyrl1860, yyrt1860 = z.DecInferLen(yyl1860, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1860 {
				if yyrl1860 <= cap(yyv1860) {
					yyv1860 = yyv1860[:yyrl1860]
				} else {
					yyv1860 = make([]HTTPIngressPath, yyrl1860)
				}
			} else {
				yyv1860 = make([]HTTPIngressPath, yyrl1860)
			}
			yyc1860 = true
			yyrr1860 = len(yyv1860)
			if yyrg1860 {
				copy(yyv1860, yyv21860)
			}
		} else if yyl1860 != len(yyv1860) {
			yyv1860 = yyv1860[:yyl1860]
			yyc1860 = true
		}
		yyj1860 := 0
		for ; yyj1860 < yyrr1860; yyj1860++ {
			yyh1860.ElemContainerState(yyj1860)
			if r.TryDecodeAsNil() {
				yyv1860[yyj1860] = HTTPIngressPath{}
			} else {
				yyv1861 := &yyv1860[yyj1860]
				yyv1861.CodecDecodeSelf(d)
			}

		}
		if yyrt1860 {
			for ; yyj1860 < yyl1860; yyj1860++ {
				yyv1860 = append(yyv1860, HTTPIngressPath{})
				yyh1860.ElemContainerState(yyj1860)
				if r.TryDecodeAsNil() {
					yyv1860[yyj1860] = HTTPIngressPath{}
				} else {
					yyv1862 := &yyv1860[yyj1860]
					yyv1862.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1860 >= len(yyv1860) {
				yyv1860 = append(yyv1860, HTTPIngressPath{}) // var yyz1860 HTTPIngressPath
				yyc1860 = true
			}
			yyh1860.ElemContainerState(yyj1860)
			if yyj1860 < len(yyv1860) {
				if r.TryDecodeAsNil() {
					yyv1860[yyj1860] = HTTPIngressPath{}
				} else {
					yyv1863 := &yyv1860[yyj1860]
					yyv1863.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1860 < len(yyv1860) {
			yyv1860 = yyv1860[:yyj1860]
			yyc1860 = true
		} else if yyj1860 == 0 && yyv1860 == nil {
			yyv1860 = []HTTPIngressPath{}
			yyc1860 = true
		}
	}
	yyh1860.End()
	if yyc1860 {
		*v = yyv1860
	}
}

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 _, yyv1864 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1865 := &yyv1864
		yy1865.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

	yyv1866 := *v
	yyh1866, yyl1866 := z.DecSliceHelperStart()
	var yyc1866 bool
	if yyl1866 == 0 {
		if yyv1866 == nil {
			yyv1866 = []LabelSelectorRequirement{}
			yyc1866 = true
		} else if len(yyv1866) != 0 {
			yyv1866 = yyv1866[:0]
			yyc1866 = true
		}
	} else if yyl1866 > 0 {
		var yyrr1866, yyrl1866 int
		var yyrt1866 bool
		if yyl1866 > cap(yyv1866) {

			yyrg1866 := len(yyv1866) > 0
			yyv21866 := yyv1866
			yyrl1866, yyrt1866 = z.DecInferLen(yyl1866, z.DecBasicHandle().MaxInitLen, 56)
			if yyrt1866 {
				if yyrl1866 <= cap(yyv1866) {
					yyv1866 = yyv1866[:yyrl1866]
				} else {
					yyv1866 = make([]LabelSelectorRequirement, yyrl1866)
				}
			} else {
				yyv1866 = make([]LabelSelectorRequirement, yyrl1866)
			}
			yyc1866 = true
			yyrr1866 = len(yyv1866)
			if yyrg1866 {
				copy(yyv1866, yyv21866)
			}
		} else if yyl1866 != len(yyv1866) {
			yyv1866 = yyv1866[:yyl1866]
			yyc1866 = true
		}
		yyj1866 := 0
		for ; yyj1866 < yyrr1866; yyj1866++ {
			yyh1866.ElemContainerState(yyj1866)
			if r.TryDecodeAsNil() {
				yyv1866[yyj1866] = LabelSelectorRequirement{}
			} else {
				yyv1867 := &yyv1866[yyj1866]
				yyv1867.CodecDecodeSelf(d)
			}

		}
		if yyrt1866 {
			for ; yyj1866 < yyl1866; yyj1866++ {
				yyv1866 = append(yyv1866, LabelSelectorRequirement{})
				yyh1866.ElemContainerState(yyj1866)
				if r.TryDecodeAsNil() {
					yyv1866[yyj1866] = LabelSelectorRequirement{}
				} else {
					yyv1868 := &yyv1866[yyj1866]
					yyv1868.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1866 >= len(yyv1866) {
				yyv1866 = append(yyv1866, LabelSelectorRequirement{}) // var yyz1866 LabelSelectorRequirement
				yyc1866 = true
			}
			yyh1866.ElemContainerState(yyj1866)
			if yyj1866 < len(yyv1866) {
				if r.TryDecodeAsNil() {
					yyv1866[yyj1866] = LabelSelectorRequirement{}
				} else {
					yyv1869 := &yyv1866[yyj1866]
					yyv1869.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1866 < len(yyv1866) {
			yyv1866 = yyv1866[:yyj1866]
			yyc1866 = true
		} else if yyj1866 == 0 && yyv1866 == nil {
			yyv1866 = []LabelSelectorRequirement{}
			yyc1866 = true
		}
	}
	yyh1866.End()
	if yyc1866 {
		*v = yyv1866
	}
}

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 _, yyv1870 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1871 := &yyv1870
		yy1871.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

	yyv1872 := *v
	yyh1872, yyl1872 := z.DecSliceHelperStart()
	var yyc1872 bool
	if yyl1872 == 0 {
		if yyv1872 == nil {
			yyv1872 = []ReplicaSet{}
			yyc1872 = true
		} else if len(yyv1872) != 0 {
			yyv1872 = yyv1872[:0]
			yyc1872 = true
		}
	} else if yyl1872 > 0 {
		var yyrr1872, yyrl1872 int
		var yyrt1872 bool
		if yyl1872 > cap(yyv1872) {

			yyrg1872 := len(yyv1872) > 0
			yyv21872 := yyv1872
			yyrl1872, yyrt1872 = z.DecInferLen(yyl1872, z.DecBasicHandle().MaxInitLen, 800)
			if yyrt1872 {
				if yyrl1872 <= cap(yyv1872) {
					yyv1872 = yyv1872[:yyrl1872]
				} else {
					yyv1872 = make([]ReplicaSet, yyrl1872)
				}
			} else {
				yyv1872 = make([]ReplicaSet, yyrl1872)
			}
			yyc1872 = true
			yyrr1872 = len(yyv1872)
			if yyrg1872 {
				copy(yyv1872, yyv21872)
			}
		} else if yyl1872 != len(yyv1872) {
			yyv1872 = yyv1872[:yyl1872]
			yyc1872 = true
		}
		yyj1872 := 0
		for ; yyj1872 < yyrr1872; yyj1872++ {
			yyh1872.ElemContainerState(yyj1872)
			if r.TryDecodeAsNil() {
				yyv1872[yyj1872] = ReplicaSet{}
			} else {
				yyv1873 := &yyv1872[yyj1872]
				yyv1873.CodecDecodeSelf(d)
			}

		}
		if yyrt1872 {
			for ; yyj1872 < yyl1872; yyj1872++ {
				yyv1872 = append(yyv1872, ReplicaSet{})
				yyh1872.ElemContainerState(yyj1872)
				if r.TryDecodeAsNil() {
					yyv1872[yyj1872] = ReplicaSet{}
				} else {
					yyv1874 := &yyv1872[yyj1872]
					yyv1874.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1872 >= len(yyv1872) {
				yyv1872 = append(yyv1872, ReplicaSet{}) // var yyz1872 ReplicaSet
				yyc1872 = true
			}
			yyh1872.ElemContainerState(yyj1872)
			if yyj1872 < len(yyv1872) {
				if r.TryDecodeAsNil() {
					yyv1872[yyj1872] = ReplicaSet{}
				} else {
					yyv1875 := &yyv1872[yyj1872]
					yyv1875.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1872 < len(yyv1872) {
			yyv1872 = yyv1872[:yyj1872]
			yyc1872 = true
		} else if yyj1872 == 0 && yyv1872 == nil {
			yyv1872 = []ReplicaSet{}
			yyc1872 = true
		}
	}
	yyh1872.End()
	if yyc1872 {
		*v = yyv1872
	}
}

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

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

	yyv1878 := *v
	yyh1878, yyl1878 := z.DecSliceHelperStart()
	var yyc1878 bool
	if yyl1878 == 0 {
		if yyv1878 == nil {
			yyv1878 = []ReplicaSetCondition{}
			yyc1878 = true
		} else if len(yyv1878) != 0 {
			yyv1878 = yyv1878[:0]
			yyc1878 = true
		}
	} else if yyl1878 > 0 {
		var yyrr1878, yyrl1878 int
		var yyrt1878 bool
		if yyl1878 > cap(yyv1878) {

			yyrg1878 := len(yyv1878) > 0
			yyv21878 := yyv1878
			yyrl1878, yyrt1878 = z.DecInferLen(yyl1878, z.DecBasicHandle().MaxInitLen, 112)
			if yyrt1878 {
				if yyrl1878 <= cap(yyv1878) {
					yyv1878 = yyv1878[:yyrl1878]
				} else {
					yyv1878 = make([]ReplicaSetCondition, yyrl1878)
				}
			} else {
				yyv1878 = make([]ReplicaSetCondition, yyrl1878)
			}
			yyc1878 = true
			yyrr1878 = len(yyv1878)
			if yyrg1878 {
				copy(yyv1878, yyv21878)
			}
		} else if yyl1878 != len(yyv1878) {
			yyv1878 = yyv1878[:yyl1878]
			yyc1878 = true
		}
		yyj1878 := 0
		for ; yyj1878 < yyrr1878; yyj1878++ {
			yyh1878.ElemContainerState(yyj1878)
			if r.TryDecodeAsNil() {
				yyv1878[yyj1878] = ReplicaSetCondition{}
			} else {
				yyv1879 := &yyv1878[yyj1878]
				yyv1879.CodecDecodeSelf(d)
			}

		}
		if yyrt1878 {
			for ; yyj1878 < yyl1878; yyj1878++ {
				yyv1878 = append(yyv1878, ReplicaSetCondition{})
				yyh1878.ElemContainerState(yyj1878)
				if r.TryDecodeAsNil() {
					yyv1878[yyj1878] = ReplicaSetCondition{}
				} else {
					yyv1880 := &yyv1878[yyj1878]
					yyv1880.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1878 >= len(yyv1878) {
				yyv1878 = append(yyv1878, ReplicaSetCondition{}) // var yyz1878 ReplicaSetCondition
				yyc1878 = true
			}
			yyh1878.ElemContainerState(yyj1878)
			if yyj1878 < len(yyv1878) {
				if r.TryDecodeAsNil() {
					yyv1878[yyj1878] = ReplicaSetCondition{}
				} else {
					yyv1881 := &yyv1878[yyj1878]
					yyv1881.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1878 < len(yyv1878) {
			yyv1878 = yyv1878[:yyj1878]
			yyc1878 = true
		} else if yyj1878 == 0 && yyv1878 == nil {
			yyv1878 = []ReplicaSetCondition{}
			yyc1878 = true
		}
	}
	yyh1878.End()
	if yyc1878 {
		*v = yyv1878
	}
}

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 _, yyv1882 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yym1883 := z.EncBinary()
		_ = yym1883
		if false {
		} else if z.HasExtensions() && z.EncExt(yyv1882) {
		} else {
			r.EncodeString(codecSelferC_UTF81234, string(yyv1882))
		}
	}
	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

	yyv1884 := *v
	yyh1884, yyl1884 := z.DecSliceHelperStart()
	var yyc1884 bool
	if yyl1884 == 0 {
		if yyv1884 == nil {
			yyv1884 = []pkg2_v1.Capability{}
			yyc1884 = true
		} else if len(yyv1884) != 0 {
			yyv1884 = yyv1884[:0]
			yyc1884 = true
		}
	} else if yyl1884 > 0 {
		var yyrr1884, yyrl1884 int
		var yyrt1884 bool
		if yyl1884 > cap(yyv1884) {

			yyrl1884, yyrt1884 = z.DecInferLen(yyl1884, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1884 {
				if yyrl1884 <= cap(yyv1884) {
					yyv1884 = yyv1884[:yyrl1884]
				} else {
					yyv1884 = make([]pkg2_v1.Capability, yyrl1884)
				}
			} else {
				yyv1884 = make([]pkg2_v1.Capability, yyrl1884)
			}
			yyc1884 = true
			yyrr1884 = len(yyv1884)
		} else if yyl1884 != len(yyv1884) {
			yyv1884 = yyv1884[:yyl1884]
			yyc1884 = true
		}
		yyj1884 := 0
		for ; yyj1884 < yyrr1884; yyj1884++ {
			yyh1884.ElemContainerState(yyj1884)
			if r.TryDecodeAsNil() {
				yyv1884[yyj1884] = ""
			} else {
				yyv1884[yyj1884] = pkg2_v1.Capability(r.DecodeString())
			}

		}
		if yyrt1884 {
			for ; yyj1884 < yyl1884; yyj1884++ {
				yyv1884 = append(yyv1884, "")
				yyh1884.ElemContainerState(yyj1884)
				if r.TryDecodeAsNil() {
					yyv1884[yyj1884] = ""
				} else {
					yyv1884[yyj1884] = pkg2_v1.Capability(r.DecodeString())
				}

			}
		}

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

			if yyj1884 >= len(yyv1884) {
				yyv1884 = append(yyv1884, "") // var yyz1884 pkg2_v1.Capability
				yyc1884 = true
			}
			yyh1884.ElemContainerState(yyj1884)
			if yyj1884 < len(yyv1884) {
				if r.TryDecodeAsNil() {
					yyv1884[yyj1884] = ""
				} else {
					yyv1884[yyj1884] = pkg2_v1.Capability(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1884 < len(yyv1884) {
			yyv1884 = yyv1884[:yyj1884]
			yyc1884 = true
		} else if yyj1884 == 0 && yyv1884 == nil {
			yyv1884 = []pkg2_v1.Capability{}
			yyc1884 = true
		}
	}
	yyh1884.End()
	if yyc1884 {
		*v = yyv1884
	}
}

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 _, yyv1888 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yyv1888.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

	yyv1889 := *v
	yyh1889, yyl1889 := z.DecSliceHelperStart()
	var yyc1889 bool
	if yyl1889 == 0 {
		if yyv1889 == nil {
			yyv1889 = []FSType{}
			yyc1889 = true
		} else if len(yyv1889) != 0 {
			yyv1889 = yyv1889[:0]
			yyc1889 = true
		}
	} else if yyl1889 > 0 {
		var yyrr1889, yyrl1889 int
		var yyrt1889 bool
		if yyl1889 > cap(yyv1889) {

			yyrl1889, yyrt1889 = z.DecInferLen(yyl1889, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1889 {
				if yyrl1889 <= cap(yyv1889) {
					yyv1889 = yyv1889[:yyrl1889]
				} else {
					yyv1889 = make([]FSType, yyrl1889)
				}
			} else {
				yyv1889 = make([]FSType, yyrl1889)
			}
			yyc1889 = true
			yyrr1889 = len(yyv1889)
		} else if yyl1889 != len(yyv1889) {
			yyv1889 = yyv1889[:yyl1889]
			yyc1889 = true
		}
		yyj1889 := 0
		for ; yyj1889 < yyrr1889; yyj1889++ {
			yyh1889.ElemContainerState(yyj1889)
			if r.TryDecodeAsNil() {
				yyv1889[yyj1889] = ""
			} else {
				yyv1889[yyj1889] = FSType(r.DecodeString())
			}

		}
		if yyrt1889 {
			for ; yyj1889 < yyl1889; yyj1889++ {
				yyv1889 = append(yyv1889, "")
				yyh1889.ElemContainerState(yyj1889)
				if r.TryDecodeAsNil() {
					yyv1889[yyj1889] = ""
				} else {
					yyv1889[yyj1889] = FSType(r.DecodeString())
				}

			}
		}

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

			if yyj1889 >= len(yyv1889) {
				yyv1889 = append(yyv1889, "") // var yyz1889 FSType
				yyc1889 = true
			}
			yyh1889.ElemContainerState(yyj1889)
			if yyj1889 < len(yyv1889) {
				if r.TryDecodeAsNil() {
					yyv1889[yyj1889] = ""
				} else {
					yyv1889[yyj1889] = FSType(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1889 < len(yyv1889) {
			yyv1889 = yyv1889[:yyj1889]
			yyc1889 = true
		} else if yyj1889 == 0 && yyv1889 == nil {
			yyv1889 = []FSType{}
			yyc1889 = true
		}
	}
	yyh1889.End()
	if yyc1889 {
		*v = yyv1889
	}
}

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 _, yyv1893 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1894 := &yyv1893
		yy1894.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

	yyv1895 := *v
	yyh1895, yyl1895 := z.DecSliceHelperStart()
	var yyc1895 bool
	if yyl1895 == 0 {
		if yyv1895 == nil {
			yyv1895 = []HostPortRange{}
			yyc1895 = true
		} else if len(yyv1895) != 0 {
			yyv1895 = yyv1895[:0]
			yyc1895 = true
		}
	} else if yyl1895 > 0 {
		var yyrr1895, yyrl1895 int
		var yyrt1895 bool
		if yyl1895 > cap(yyv1895) {

			yyrg1895 := len(yyv1895) > 0
			yyv21895 := yyv1895
			yyrl1895, yyrt1895 = z.DecInferLen(yyl1895, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1895 {
				if yyrl1895 <= cap(yyv1895) {
					yyv1895 = yyv1895[:yyrl1895]
				} else {
					yyv1895 = make([]HostPortRange, yyrl1895)
				}
			} else {
				yyv1895 = make([]HostPortRange, yyrl1895)
			}
			yyc1895 = true
			yyrr1895 = len(yyv1895)
			if yyrg1895 {
				copy(yyv1895, yyv21895)
			}
		} else if yyl1895 != len(yyv1895) {
			yyv1895 = yyv1895[:yyl1895]
			yyc1895 = true
		}
		yyj1895 := 0
		for ; yyj1895 < yyrr1895; yyj1895++ {
			yyh1895.ElemContainerState(yyj1895)
			if r.TryDecodeAsNil() {
				yyv1895[yyj1895] = HostPortRange{}
			} else {
				yyv1896 := &yyv1895[yyj1895]
				yyv1896.CodecDecodeSelf(d)
			}

		}
		if yyrt1895 {
			for ; yyj1895 < yyl1895; yyj1895++ {
				yyv1895 = append(yyv1895, HostPortRange{})
				yyh1895.ElemContainerState(yyj1895)
				if r.TryDecodeAsNil() {
					yyv1895[yyj1895] = HostPortRange{}
				} else {
					yyv1897 := &yyv1895[yyj1895]
					yyv1897.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1895 >= len(yyv1895) {
				yyv1895 = append(yyv1895, HostPortRange{}) // var yyz1895 HostPortRange
				yyc1895 = true
			}
			yyh1895.ElemContainerState(yyj1895)
			if yyj1895 < len(yyv1895) {
				if r.TryDecodeAsNil() {
					yyv1895[yyj1895] = HostPortRange{}
				} else {
					yyv1898 := &yyv1895[yyj1895]
					yyv1898.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1895 < len(yyv1895) {
			yyv1895 = yyv1895[:yyj1895]
			yyc1895 = true
		} else if yyj1895 == 0 && yyv1895 == nil {
			yyv1895 = []HostPortRange{}
			yyc1895 = true
		}
	}
	yyh1895.End()
	if yyc1895 {
		*v = yyv1895
	}
}

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 _, yyv1899 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1900 := &yyv1899
		yy1900.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

	yyv1901 := *v
	yyh1901, yyl1901 := z.DecSliceHelperStart()
	var yyc1901 bool
	if yyl1901 == 0 {
		if yyv1901 == nil {
			yyv1901 = []IDRange{}
			yyc1901 = true
		} else if len(yyv1901) != 0 {
			yyv1901 = yyv1901[:0]
			yyc1901 = true
		}
	} else if yyl1901 > 0 {
		var yyrr1901, yyrl1901 int
		var yyrt1901 bool
		if yyl1901 > cap(yyv1901) {

			yyrg1901 := len(yyv1901) > 0
			yyv21901 := yyv1901
			yyrl1901, yyrt1901 = z.DecInferLen(yyl1901, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1901 {
				if yyrl1901 <= cap(yyv1901) {
					yyv1901 = yyv1901[:yyrl1901]
				} else {
					yyv1901 = make([]IDRange, yyrl1901)
				}
			} else {
				yyv1901 = make([]IDRange, yyrl1901)
			}
			yyc1901 = true
			yyrr1901 = len(yyv1901)
			if yyrg1901 {
				copy(yyv1901, yyv21901)
			}
		} else if yyl1901 != len(yyv1901) {
			yyv1901 = yyv1901[:yyl1901]
			yyc1901 = true
		}
		yyj1901 := 0
		for ; yyj1901 < yyrr1901; yyj1901++ {
			yyh1901.ElemContainerState(yyj1901)
			if r.TryDecodeAsNil() {
				yyv1901[yyj1901] = IDRange{}
			} else {
				yyv1902 := &yyv1901[yyj1901]
				yyv1902.CodecDecodeSelf(d)
			}

		}
		if yyrt1901 {
			for ; yyj1901 < yyl1901; yyj1901++ {
				yyv1901 = append(yyv1901, IDRange{})
				yyh1901.ElemContainerState(yyj1901)
				if r.TryDecodeAsNil() {
					yyv1901[yyj1901] = IDRange{}
				} else {
					yyv1903 := &yyv1901[yyj1901]
					yyv1903.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1901 >= len(yyv1901) {
				yyv1901 = append(yyv1901, IDRange{}) // var yyz1901 IDRange
				yyc1901 = true
			}
			yyh1901.ElemContainerState(yyj1901)
			if yyj1901 < len(yyv1901) {
				if r.TryDecodeAsNil() {
					yyv1901[yyj1901] = IDRange{}
				} else {
					yyv1904 := &yyv1901[yyj1901]
					yyv1904.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1901 < len(yyv1901) {
			yyv1901 = yyv1901[:yyj1901]
			yyc1901 = true
		} else if yyj1901 == 0 && yyv1901 == nil {
			yyv1901 = []IDRange{}
			yyc1901 = true
		}
	}
	yyh1901.End()
	if yyc1901 {
		*v = yyv1901
	}
}

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 _, yyv1905 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1906 := &yyv1905
		yy1906.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

	yyv1907 := *v
	yyh1907, yyl1907 := z.DecSliceHelperStart()
	var yyc1907 bool
	if yyl1907 == 0 {
		if yyv1907 == nil {
			yyv1907 = []PodSecurityPolicy{}
			yyc1907 = true
		} else if len(yyv1907) != 0 {
			yyv1907 = yyv1907[:0]
			yyc1907 = true
		}
	} else if yyl1907 > 0 {
		var yyrr1907, yyrl1907 int
		var yyrt1907 bool
		if yyl1907 > cap(yyv1907) {

			yyrg1907 := len(yyv1907) > 0
			yyv21907 := yyv1907
			yyrl1907, yyrt1907 = z.DecInferLen(yyl1907, z.DecBasicHandle().MaxInitLen, 552)
			if yyrt1907 {
				if yyrl1907 <= cap(yyv1907) {
					yyv1907 = yyv1907[:yyrl1907]
				} else {
					yyv1907 = make([]PodSecurityPolicy, yyrl1907)
				}
			} else {
				yyv1907 = make([]PodSecurityPolicy, yyrl1907)
			}
			yyc1907 = true
			yyrr1907 = len(yyv1907)
			if yyrg1907 {
				copy(yyv1907, yyv21907)
			}
		} else if yyl1907 != len(yyv1907) {
			yyv1907 = yyv1907[:yyl1907]
			yyc1907 = true
		}
		yyj1907 := 0
		for ; yyj1907 < yyrr1907; yyj1907++ {
			yyh1907.ElemContainerState(yyj1907)
			if r.TryDecodeAsNil() {
				yyv1907[yyj1907] = PodSecurityPolicy{}
			} else {
				yyv1908 := &yyv1907[yyj1907]
				yyv1908.CodecDecodeSelf(d)
			}

		}
		if yyrt1907 {
			for ; yyj1907 < yyl1907; yyj1907++ {
				yyv1907 = append(yyv1907, PodSecurityPolicy{})
				yyh1907.ElemContainerState(yyj1907)
				if r.TryDecodeAsNil() {
					yyv1907[yyj1907] = PodSecurityPolicy{}
				} else {
					yyv1909 := &yyv1907[yyj1907]
					yyv1909.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1907 >= len(yyv1907) {
				yyv1907 = append(yyv1907, PodSecurityPolicy{}) // var yyz1907 PodSecurityPolicy
				yyc1907 = true
			}
			yyh1907.ElemContainerState(yyj1907)
			if yyj1907 < len(yyv1907) {
				if r.TryDecodeAsNil() {
					yyv1907[yyj1907] = PodSecurityPolicy{}
				} else {
					yyv1910 := &yyv1907[yyj1907]
					yyv1910.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1907 < len(yyv1907) {
			yyv1907 = yyv1907[:yyj1907]
			yyc1907 = true
		} else if yyj1907 == 0 && yyv1907 == nil {
			yyv1907 = []PodSecurityPolicy{}
			yyc1907 = true
		}
	}
	yyh1907.End()
	if yyc1907 {
		*v = yyv1907
	}
}

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 _, yyv1911 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1912 := &yyv1911
		yy1912.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

	yyv1913 := *v
	yyh1913, yyl1913 := z.DecSliceHelperStart()
	var yyc1913 bool
	if yyl1913 == 0 {
		if yyv1913 == nil {
			yyv1913 = []NetworkPolicyIngressRule{}
			yyc1913 = true
		} else if len(yyv1913) != 0 {
			yyv1913 = yyv1913[:0]
			yyc1913 = true
		}
	} else if yyl1913 > 0 {
		var yyrr1913, yyrl1913 int
		var yyrt1913 bool
		if yyl1913 > cap(yyv1913) {

			yyrg1913 := len(yyv1913) > 0
			yyv21913 := yyv1913
			yyrl1913, yyrt1913 = z.DecInferLen(yyl1913, z.DecBasicHandle().MaxInitLen, 48)
			if yyrt1913 {
				if yyrl1913 <= cap(yyv1913) {
					yyv1913 = yyv1913[:yyrl1913]
				} else {
					yyv1913 = make([]NetworkPolicyIngressRule, yyrl1913)
				}
			} else {
				yyv1913 = make([]NetworkPolicyIngressRule, yyrl1913)
			}
			yyc1913 = true
			yyrr1913 = len(yyv1913)
			if yyrg1913 {
				copy(yyv1913, yyv21913)
			}
		} else if yyl1913 != len(yyv1913) {
			yyv1913 = yyv1913[:yyl1913]
			yyc1913 = true
		}
		yyj1913 := 0
		for ; yyj1913 < yyrr1913; yyj1913++ {
			yyh1913.ElemContainerState(yyj1913)
			if r.TryDecodeAsNil() {
				yyv1913[yyj1913] = NetworkPolicyIngressRule{}
			} else {
				yyv1914 := &yyv1913[yyj1913]
				yyv1914.CodecDecodeSelf(d)
			}

		}
		if yyrt1913 {
			for ; yyj1913 < yyl1913; yyj1913++ {
				yyv1913 = append(yyv1913, NetworkPolicyIngressRule{})
				yyh1913.ElemContainerState(yyj1913)
				if r.TryDecodeAsNil() {
					yyv1913[yyj1913] = NetworkPolicyIngressRule{}
				} else {
					yyv1915 := &yyv1913[yyj1913]
					yyv1915.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1913 >= len(yyv1913) {
				yyv1913 = append(yyv1913, NetworkPolicyIngressRule{}) // var yyz1913 NetworkPolicyIngressRule
				yyc1913 = true
			}
			yyh1913.ElemContainerState(yyj1913)
			if yyj1913 < len(yyv1913) {
				if r.TryDecodeAsNil() {
					yyv1913[yyj1913] = NetworkPolicyIngressRule{}
				} else {
					yyv1916 := &yyv1913[yyj1913]
					yyv1916.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1913 < len(yyv1913) {
			yyv1913 = yyv1913[:yyj1913]
			yyc1913 = true
		} else if yyj1913 == 0 && yyv1913 == nil {
			yyv1913 = []NetworkPolicyIngressRule{}
			yyc1913 = true
		}
	}
	yyh1913.End()
	if yyc1913 {
		*v = yyv1913
	}
}

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 _, yyv1917 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1918 := &yyv1917
		yy1918.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

	yyv1919 := *v
	yyh1919, yyl1919 := z.DecSliceHelperStart()
	var yyc1919 bool
	if yyl1919 == 0 {
		if yyv1919 == nil {
			yyv1919 = []NetworkPolicyPort{}
			yyc1919 = true
		} else if len(yyv1919) != 0 {
			yyv1919 = yyv1919[:0]
			yyc1919 = true
		}
	} else if yyl1919 > 0 {
		var yyrr1919, yyrl1919 int
		var yyrt1919 bool
		if yyl1919 > cap(yyv1919) {

			yyrg1919 := len(yyv1919) > 0
			yyv21919 := yyv1919
			yyrl1919, yyrt1919 = z.DecInferLen(yyl1919, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1919 {
				if yyrl1919 <= cap(yyv1919) {
					yyv1919 = yyv1919[:yyrl1919]
				} else {
					yyv1919 = make([]NetworkPolicyPort, yyrl1919)
				}
			} else {
				yyv1919 = make([]NetworkPolicyPort, yyrl1919)
			}
			yyc1919 = true
			yyrr1919 = len(yyv1919)
			if yyrg1919 {
				copy(yyv1919, yyv21919)
			}
		} else if yyl1919 != len(yyv1919) {
			yyv1919 = yyv1919[:yyl1919]
			yyc1919 = true
		}
		yyj1919 := 0
		for ; yyj1919 < yyrr1919; yyj1919++ {
			yyh1919.ElemContainerState(yyj1919)
			if r.TryDecodeAsNil() {
				yyv1919[yyj1919] = NetworkPolicyPort{}
			} else {
				yyv1920 := &yyv1919[yyj1919]
				yyv1920.CodecDecodeSelf(d)
			}

		}
		if yyrt1919 {
			for ; yyj1919 < yyl1919; yyj1919++ {
				yyv1919 = append(yyv1919, NetworkPolicyPort{})
				yyh1919.ElemContainerState(yyj1919)
				if r.TryDecodeAsNil() {
					yyv1919[yyj1919] = NetworkPolicyPort{}
				} else {
					yyv1921 := &yyv1919[yyj1919]
					yyv1921.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1919 >= len(yyv1919) {
				yyv1919 = append(yyv1919, NetworkPolicyPort{}) // var yyz1919 NetworkPolicyPort
				yyc1919 = true
			}
			yyh1919.ElemContainerState(yyj1919)
			if yyj1919 < len(yyv1919) {
				if r.TryDecodeAsNil() {
					yyv1919[yyj1919] = NetworkPolicyPort{}
				} else {
					yyv1922 := &yyv1919[yyj1919]
					yyv1922.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1919 < len(yyv1919) {
			yyv1919 = yyv1919[:yyj1919]
			yyc1919 = true
		} else if yyj1919 == 0 && yyv1919 == nil {
			yyv1919 = []NetworkPolicyPort{}
			yyc1919 = true
		}
	}
	yyh1919.End()
	if yyc1919 {
		*v = yyv1919
	}
}

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 _, yyv1923 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1924 := &yyv1923
		yy1924.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

	yyv1925 := *v
	yyh1925, yyl1925 := z.DecSliceHelperStart()
	var yyc1925 bool
	if yyl1925 == 0 {
		if yyv1925 == nil {
			yyv1925 = []NetworkPolicyPeer{}
			yyc1925 = true
		} else if len(yyv1925) != 0 {
			yyv1925 = yyv1925[:0]
			yyc1925 = true
		}
	} else if yyl1925 > 0 {
		var yyrr1925, yyrl1925 int
		var yyrt1925 bool
		if yyl1925 > cap(yyv1925) {

			yyrg1925 := len(yyv1925) > 0
			yyv21925 := yyv1925
			yyrl1925, yyrt1925 = z.DecInferLen(yyl1925, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1925 {
				if yyrl1925 <= cap(yyv1925) {
					yyv1925 = yyv1925[:yyrl1925]
				} else {
					yyv1925 = make([]NetworkPolicyPeer, yyrl1925)
				}
			} else {
				yyv1925 = make([]NetworkPolicyPeer, yyrl1925)
			}
			yyc1925 = true
			yyrr1925 = len(yyv1925)
			if yyrg1925 {
				copy(yyv1925, yyv21925)
			}
		} else if yyl1925 != len(yyv1925) {
			yyv1925 = yyv1925[:yyl1925]
			yyc1925 = true
		}
		yyj1925 := 0
		for ; yyj1925 < yyrr1925; yyj1925++ {
			yyh1925.ElemContainerState(yyj1925)
			if r.TryDecodeAsNil() {
				yyv1925[yyj1925] = NetworkPolicyPeer{}
			} else {
				yyv1926 := &yyv1925[yyj1925]
				yyv1926.CodecDecodeSelf(d)
			}

		}
		if yyrt1925 {
			for ; yyj1925 < yyl1925; yyj1925++ {
				yyv1925 = append(yyv1925, NetworkPolicyPeer{})
				yyh1925.ElemContainerState(yyj1925)
				if r.TryDecodeAsNil() {
					yyv1925[yyj1925] = NetworkPolicyPeer{}
				} else {
					yyv1927 := &yyv1925[yyj1925]
					yyv1927.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1925 >= len(yyv1925) {
				yyv1925 = append(yyv1925, NetworkPolicyPeer{}) // var yyz1925 NetworkPolicyPeer
				yyc1925 = true
			}
			yyh1925.ElemContainerState(yyj1925)
			if yyj1925 < len(yyv1925) {
				if r.TryDecodeAsNil() {
					yyv1925[yyj1925] = NetworkPolicyPeer{}
				} else {
					yyv1928 := &yyv1925[yyj1925]
					yyv1928.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1925 < len(yyv1925) {
			yyv1925 = yyv1925[:yyj1925]
			yyc1925 = true
		} else if yyj1925 == 0 && yyv1925 == nil {
			yyv1925 = []NetworkPolicyPeer{}
			yyc1925 = true
		}
	}
	yyh1925.End()
	if yyc1925 {
		*v = yyv1925
	}
}

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 _, yyv1929 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1930 := &yyv1929
		yy1930.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

	yyv1931 := *v
	yyh1931, yyl1931 := z.DecSliceHelperStart()
	var yyc1931 bool
	if yyl1931 == 0 {
		if yyv1931 == nil {
			yyv1931 = []NetworkPolicy{}
			yyc1931 = true
		} else if len(yyv1931) != 0 {
			yyv1931 = yyv1931[:0]
			yyc1931 = true
		}
	} else if yyl1931 > 0 {
		var yyrr1931, yyrl1931 int
		var yyrt1931 bool
		if yyl1931 > cap(yyv1931) {

			yyrg1931 := len(yyv1931) > 0
			yyv21931 := yyv1931
			yyrl1931, yyrt1931 = z.DecInferLen(yyl1931, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1931 {
				if yyrl1931 <= cap(yyv1931) {
					yyv1931 = yyv1931[:yyrl1931]
				} else {
					yyv1931 = make([]NetworkPolicy, yyrl1931)
				}
			} else {
				yyv1931 = make([]NetworkPolicy, yyrl1931)
			}
			yyc1931 = true
			yyrr1931 = len(yyv1931)
			if yyrg1931 {
				copy(yyv1931, yyv21931)
			}
		} else if yyl1931 != len(yyv1931) {
			yyv1931 = yyv1931[:yyl1931]
			yyc1931 = true
		}
		yyj1931 := 0
		for ; yyj1931 < yyrr1931; yyj1931++ {
			yyh1931.ElemContainerState(yyj1931)
			if r.TryDecodeAsNil() {
				yyv1931[yyj1931] = NetworkPolicy{}
			} else {
				yyv1932 := &yyv1931[yyj1931]
				yyv1932.CodecDecodeSelf(d)
			}

		}
		if yyrt1931 {
			for ; yyj1931 < yyl1931; yyj1931++ {
				yyv1931 = append(yyv1931, NetworkPolicy{})
				yyh1931.ElemContainerState(yyj1931)
				if r.TryDecodeAsNil() {
					yyv1931[yyj1931] = NetworkPolicy{}
				} else {
					yyv1933 := &yyv1931[yyj1931]
					yyv1933.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1931 >= len(yyv1931) {
				yyv1931 = append(yyv1931, NetworkPolicy{}) // var yyz1931 NetworkPolicy
				yyc1931 = true
			}
			yyh1931.ElemContainerState(yyj1931)
			if yyj1931 < len(yyv1931) {
				if r.TryDecodeAsNil() {
					yyv1931[yyj1931] = NetworkPolicy{}
				} else {
					yyv1934 := &yyv1931[yyj1931]
					yyv1934.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1931 < len(yyv1931) {
			yyv1931 = yyv1931[:yyj1931]
			yyc1931 = true
		} else if yyj1931 == 0 && yyv1931 == nil {
			yyv1931 = []NetworkPolicy{}
			yyc1931 = true
		}
	}
	yyh1931.End()
	if yyc1931 {
		*v = yyv1931
	}
}