/*
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 extensions

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

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

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

type codecSelfer1234 struct{}

func init() {
	if codec1978.GenVersion != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg2_api.ObjectMeta
		var v1 pkg4_resource.Quantity
		var v2 pkg1_unversioned.LabelSelector
		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 [2]bool
			_, _, _ = yysep13, yyq13, yy2arr13
			const yyr13 bool = false
			yyq13[1] = x.Selector != nil
			var yynn13 int
			if yyr13 || yy2arr13 {
				r.EncodeArrayStart(2)
			} 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 if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} 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 if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			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
	yym20 := z.DecBinary()
	_ = yym20
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct21 := r.ContainerType()
		if yyct21 == codecSelferValueTypeMap1234 {
			yyl21 := r.ReadMapStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl21, d)
			}
		} else if yyct21 == codecSelferValueTypeArray1234 {
			yyl21 := r.ReadArrayStart()
			if yyl21 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl21, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ScaleStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys22Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys22Slc
	var yyhl22 bool = l >= 0
	for yyj22 := 0; ; yyj22++ {
		if yyhl22 {
			if yyj22 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys22Slc = r.DecodeBytes(yys22Slc, true, true)
		yys22 := string(yys22Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys22 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				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(pkg1_unversioned.LabelSelector)
				}
				yym25 := z.DecBinary()
				_ = yym25
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys22)
		} // end switch yys22
	} // end for yyj22
	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 yyj26 int
	var yyb26 bool
	var yyhl26 bool = l >= 0
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym29 := z.DecBinary()
		_ = yym29
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	for {
		yyj26++
		if yyhl26 {
			yyb26 = yyj26 > l
		} else {
			yyb26 = r.CheckBreak()
		}
		if yyb26 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj26-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 {
		yym30 := z.EncBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep31 := !z.EncBinary()
			yy2arr31 := z.EncBasicHandle().StructToArray
			var yyq31 [5]bool
			_, _, _ = yysep31, yyq31, yy2arr31
			const yyr31 bool = false
			yyq31[0] = x.Kind != ""
			yyq31[1] = x.APIVersion != ""
			yyq31[2] = true
			yyq31[3] = true
			yyq31[4] = true
			var yynn31 int
			if yyr31 || yy2arr31 {
				r.EncodeArrayStart(5)
			} else {
				yynn31 = 0
				for _, b := range yyq31 {
					if b {
						yynn31++
					}
				}
				r.EncodeMapStart(yynn31)
				yynn31 = 0
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[0] {
					yym33 := z.EncBinary()
					_ = yym33
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym34 := z.EncBinary()
					_ = yym34
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[1] {
					yym36 := z.EncBinary()
					_ = yym36
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq31[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym37 := z.EncBinary()
					_ = yym37
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[2] {
					yy39 := &x.ObjectMeta
					yy39.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy40 := &x.ObjectMeta
					yy40.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[3] {
					yy42 := &x.Spec
					yy42.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy43 := &x.Spec
					yy43.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq31[4] {
					yy45 := &x.Status
					yy45.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq31[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy46 := &x.Status
					yy46.CodecEncodeSelf(e)
				}
			}
			if yyr31 || yy2arr31 {
				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
	yym47 := z.DecBinary()
	_ = yym47
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct48 := r.ContainerType()
		if yyct48 == codecSelferValueTypeMap1234 {
			yyl48 := r.ReadMapStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl48, d)
			}
		} else if yyct48 == codecSelferValueTypeArray1234 {
			yyl48 := r.ReadArrayStart()
			if yyl48 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl48, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *Scale) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys49Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys49Slc
	var yyhl49 bool = l >= 0
	for yyj49 := 0; ; yyj49++ {
		if yyhl49 {
			if yyj49 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys49Slc = r.DecodeBytes(yys49Slc, true, true)
		yys49 := string(yys49Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys49 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv52 := &x.ObjectMeta
				yyv52.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ScaleSpec{}
			} else {
				yyv53 := &x.Spec
				yyv53.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ScaleStatus{}
			} else {
				yyv54 := &x.Status
				yyv54.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys49)
		} // end switch yys49
	} // end for yyj49
	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 yyj55 int
	var yyb55 bool
	var yyhl55 bool = l >= 0
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv58 := &x.ObjectMeta
		yyv58.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ScaleSpec{}
	} else {
		yyv59 := &x.Spec
		yyv59.CodecDecodeSelf(d)
	}
	yyj55++
	if yyhl55 {
		yyb55 = yyj55 > l
	} else {
		yyb55 = r.CheckBreak()
	}
	if yyb55 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ScaleStatus{}
	} else {
		yyv60 := &x.Status
		yyv60.CodecDecodeSelf(d)
	}
	for {
		yyj55++
		if yyhl55 {
			yyb55 = yyj55 > l
		} else {
			yyb55 = r.CheckBreak()
		}
		if yyb55 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj55-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 {
		yym61 := z.EncBinary()
		_ = yym61
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep62 := !z.EncBinary()
			yy2arr62 := z.EncBasicHandle().StructToArray
			var yyq62 [2]bool
			_, _, _ = yysep62, yyq62, yy2arr62
			const yyr62 bool = false
			yyq62[0] = x.Kind != ""
			yyq62[1] = x.APIVersion != ""
			var yynn62 int
			if yyr62 || yy2arr62 {
				r.EncodeArrayStart(2)
			} else {
				yynn62 = 0
				for _, b := range yyq62 {
					if b {
						yynn62++
					}
				}
				r.EncodeMapStart(yynn62)
				yynn62 = 0
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[0] {
					yym64 := z.EncBinary()
					_ = yym64
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym65 := z.EncBinary()
					_ = yym65
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr62 || yy2arr62 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq62[1] {
					yym67 := z.EncBinary()
					_ = yym67
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq62[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym68 := z.EncBinary()
					_ = yym68
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr62 || yy2arr62 {
				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
	yym69 := z.DecBinary()
	_ = yym69
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct70 := r.ContainerType()
		if yyct70 == codecSelferValueTypeMap1234 {
			yyl70 := r.ReadMapStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl70, d)
			}
		} else if yyct70 == codecSelferValueTypeArray1234 {
			yyl70 := r.ReadArrayStart()
			if yyl70 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl70, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ReplicationControllerDummy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys71Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys71Slc
	var yyhl71 bool = l >= 0
	for yyj71 := 0; ; yyj71++ {
		if yyhl71 {
			if yyj71 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys71Slc = r.DecodeBytes(yys71Slc, true, true)
		yys71 := string(yys71Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys71 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys71)
		} // end switch yys71
	} // end for yyj71
	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 yyj74 int
	var yyb74 bool
	var yyhl74 bool = l >= 0
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	for {
		yyj74++
		if yyhl74 {
			yyb74 = yyj74 > l
		} else {
			yyb74 = r.CheckBreak()
		}
		if yyb74 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj74-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 {
		yym77 := z.EncBinary()
		_ = yym77
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep78 := !z.EncBinary()
			yy2arr78 := z.EncBasicHandle().StructToArray
			var yyq78 [2]bool
			_, _, _ = yysep78, yyq78, yy2arr78
			const yyr78 bool = false
			var yynn78 int
			if yyr78 || yy2arr78 {
				r.EncodeArrayStart(2)
			} else {
				yynn78 = 2
				for _, b := range yyq78 {
					if b {
						yynn78++
					}
				}
				r.EncodeMapStart(yynn78)
				yynn78 = 0
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym80 := z.EncBinary()
				_ = yym80
				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)
				yym81 := z.EncBinary()
				_ = yym81
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr78 || yy2arr78 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy83 := &x.TargetValue
				yym84 := z.EncBinary()
				_ = yym84
				if false {
				} else if z.HasExtensions() && z.EncExt(yy83) {
				} else if !yym84 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy83)
				} else {
					z.EncFallback(yy83)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy85 := &x.TargetValue
				yym86 := z.EncBinary()
				_ = yym86
				if false {
				} else if z.HasExtensions() && z.EncExt(yy85) {
				} else if !yym86 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy85)
				} else {
					z.EncFallback(yy85)
				}
			}
			if yyr78 || yy2arr78 {
				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
	yym87 := z.DecBinary()
	_ = yym87
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct88 := r.ContainerType()
		if yyct88 == codecSelferValueTypeMap1234 {
			yyl88 := r.ReadMapStart()
			if yyl88 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl88, d)
			}
		} else if yyct88 == codecSelferValueTypeArray1234 {
			yyl88 := r.ReadArrayStart()
			if yyl88 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl88, 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 yys89Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys89Slc
	var yyhl89 bool = l >= 0
	for yyj89 := 0; ; yyj89++ {
		if yyhl89 {
			if yyj89 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys89Slc = r.DecodeBytes(yys89Slc, true, true)
		yys89 := string(yys89Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys89 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.TargetValue = pkg4_resource.Quantity{}
			} else {
				yyv91 := &x.TargetValue
				yym92 := z.DecBinary()
				_ = yym92
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv91) {
				} else if !yym92 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv91)
				} else {
					z.DecFallback(yyv91, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys89)
		} // end switch yys89
	} // end for yyj89
	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 yyj93 int
	var yyb93 bool
	var yyhl93 bool = l >= 0
	yyj93++
	if yyhl93 {
		yyb93 = yyj93 > l
	} else {
		yyb93 = r.CheckBreak()
	}
	if yyb93 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj93++
	if yyhl93 {
		yyb93 = yyj93 > l
	} else {
		yyb93 = r.CheckBreak()
	}
	if yyb93 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TargetValue = pkg4_resource.Quantity{}
	} else {
		yyv95 := &x.TargetValue
		yym96 := z.DecBinary()
		_ = yym96
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv95) {
		} else if !yym96 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv95)
		} else {
			z.DecFallback(yyv95, false)
		}
	}
	for {
		yyj93++
		if yyhl93 {
			yyb93 = yyj93 > l
		} else {
			yyb93 = r.CheckBreak()
		}
		if yyb93 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj93-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 {
		yym97 := z.EncBinary()
		_ = yym97
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep98 := !z.EncBinary()
			yy2arr98 := z.EncBasicHandle().StructToArray
			var yyq98 [1]bool
			_, _, _ = yysep98, yyq98, yy2arr98
			const yyr98 bool = false
			var yynn98 int
			if yyr98 || yy2arr98 {
				r.EncodeArrayStart(1)
			} else {
				yynn98 = 1
				for _, b := range yyq98 {
					if b {
						yynn98++
					}
				}
				r.EncodeMapStart(yynn98)
				yynn98 = 0
			}
			if yyr98 || yy2arr98 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym100 := z.EncBinary()
					_ = yym100
					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 {
					yym101 := z.EncBinary()
					_ = yym101
					if false {
					} else {
						h.encSliceCustomMetricTarget(([]CustomMetricTarget)(x.Items), e)
					}
				}
			}
			if yyr98 || yy2arr98 {
				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
	yym102 := z.DecBinary()
	_ = yym102
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct103 := r.ContainerType()
		if yyct103 == codecSelferValueTypeMap1234 {
			yyl103 := r.ReadMapStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl103, d)
			}
		} else if yyct103 == codecSelferValueTypeArray1234 {
			yyl103 := r.ReadArrayStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl103, 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 yys104Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys104Slc
	var yyhl104 bool = l >= 0
	for yyj104 := 0; ; yyj104++ {
		if yyhl104 {
			if yyj104 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys104Slc = r.DecodeBytes(yys104Slc, true, true)
		yys104 := string(yys104Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys104 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv105 := &x.Items
				yym106 := z.DecBinary()
				_ = yym106
				if false {
				} else {
					h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv105), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys104)
		} // end switch yys104
	} // end for yyj104
	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 yyj107 int
	var yyb107 bool
	var yyhl107 bool = l >= 0
	yyj107++
	if yyhl107 {
		yyb107 = yyj107 > l
	} else {
		yyb107 = r.CheckBreak()
	}
	if yyb107 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv108 := &x.Items
		yym109 := z.DecBinary()
		_ = yym109
		if false {
		} else {
			h.decSliceCustomMetricTarget((*[]CustomMetricTarget)(yyv108), d)
		}
	}
	for {
		yyj107++
		if yyhl107 {
			yyb107 = yyj107 > l
		} else {
			yyb107 = r.CheckBreak()
		}
		if yyb107 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj107-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 {
		yym110 := z.EncBinary()
		_ = yym110
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep111 := !z.EncBinary()
			yy2arr111 := z.EncBasicHandle().StructToArray
			var yyq111 [2]bool
			_, _, _ = yysep111, yyq111, yy2arr111
			const yyr111 bool = false
			var yynn111 int
			if yyr111 || yy2arr111 {
				r.EncodeArrayStart(2)
			} else {
				yynn111 = 2
				for _, b := range yyq111 {
					if b {
						yynn111++
					}
				}
				r.EncodeMapStart(yynn111)
				yynn111 = 0
			}
			if yyr111 || yy2arr111 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym113 := z.EncBinary()
				_ = yym113
				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)
				yym114 := z.EncBinary()
				_ = yym114
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr111 || yy2arr111 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy116 := &x.CurrentValue
				yym117 := z.EncBinary()
				_ = yym117
				if false {
				} else if z.HasExtensions() && z.EncExt(yy116) {
				} else if !yym117 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy116)
				} else {
					z.EncFallback(yy116)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("value"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy118 := &x.CurrentValue
				yym119 := z.EncBinary()
				_ = yym119
				if false {
				} else if z.HasExtensions() && z.EncExt(yy118) {
				} else if !yym119 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy118)
				} else {
					z.EncFallback(yy118)
				}
			}
			if yyr111 || yy2arr111 {
				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
	yym120 := z.DecBinary()
	_ = yym120
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct121 := r.ContainerType()
		if yyct121 == codecSelferValueTypeMap1234 {
			yyl121 := r.ReadMapStart()
			if yyl121 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl121, d)
			}
		} else if yyct121 == codecSelferValueTypeArray1234 {
			yyl121 := r.ReadArrayStart()
			if yyl121 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl121, 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 yys122Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys122Slc
	var yyhl122 bool = l >= 0
	for yyj122 := 0; ; yyj122++ {
		if yyhl122 {
			if yyj122 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys122Slc = r.DecodeBytes(yys122Slc, true, true)
		yys122 := string(yys122Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys122 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.CurrentValue = pkg4_resource.Quantity{}
			} else {
				yyv124 := &x.CurrentValue
				yym125 := z.DecBinary()
				_ = yym125
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv124) {
				} else if !yym125 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv124)
				} else {
					z.DecFallback(yyv124, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys122)
		} // end switch yys122
	} // end for yyj122
	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 yyj126 int
	var yyb126 bool
	var yyhl126 bool = l >= 0
	yyj126++
	if yyhl126 {
		yyb126 = yyj126 > l
	} else {
		yyb126 = r.CheckBreak()
	}
	if yyb126 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj126++
	if yyhl126 {
		yyb126 = yyj126 > l
	} else {
		yyb126 = r.CheckBreak()
	}
	if yyb126 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentValue = pkg4_resource.Quantity{}
	} else {
		yyv128 := &x.CurrentValue
		yym129 := z.DecBinary()
		_ = yym129
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv128) {
		} else if !yym129 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv128)
		} else {
			z.DecFallback(yyv128, false)
		}
	}
	for {
		yyj126++
		if yyhl126 {
			yyb126 = yyj126 > l
		} else {
			yyb126 = r.CheckBreak()
		}
		if yyb126 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj126-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 {
		yym130 := z.EncBinary()
		_ = yym130
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep131 := !z.EncBinary()
			yy2arr131 := z.EncBasicHandle().StructToArray
			var yyq131 [1]bool
			_, _, _ = yysep131, yyq131, yy2arr131
			const yyr131 bool = false
			var yynn131 int
			if yyr131 || yy2arr131 {
				r.EncodeArrayStart(1)
			} else {
				yynn131 = 1
				for _, b := range yyq131 {
					if b {
						yynn131++
					}
				}
				r.EncodeMapStart(yynn131)
				yynn131 = 0
			}
			if yyr131 || yy2arr131 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym133 := z.EncBinary()
					_ = yym133
					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 {
					yym134 := z.EncBinary()
					_ = yym134
					if false {
					} else {
						h.encSliceCustomMetricCurrentStatus(([]CustomMetricCurrentStatus)(x.Items), e)
					}
				}
			}
			if yyr131 || yy2arr131 {
				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
	yym135 := z.DecBinary()
	_ = yym135
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct136 := r.ContainerType()
		if yyct136 == codecSelferValueTypeMap1234 {
			yyl136 := r.ReadMapStart()
			if yyl136 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl136, d)
			}
		} else if yyct136 == codecSelferValueTypeArray1234 {
			yyl136 := r.ReadArrayStart()
			if yyl136 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl136, 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 yys137Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys137Slc
	var yyhl137 bool = l >= 0
	for yyj137 := 0; ; yyj137++ {
		if yyhl137 {
			if yyj137 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys137Slc = r.DecodeBytes(yys137Slc, true, true)
		yys137 := string(yys137Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys137 {
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv138 := &x.Items
				yym139 := z.DecBinary()
				_ = yym139
				if false {
				} else {
					h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv138), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys137)
		} // end switch yys137
	} // end for yyj137
	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 yyj140 int
	var yyb140 bool
	var yyhl140 bool = l >= 0
	yyj140++
	if yyhl140 {
		yyb140 = yyj140 > l
	} else {
		yyb140 = r.CheckBreak()
	}
	if yyb140 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv141 := &x.Items
		yym142 := z.DecBinary()
		_ = yym142
		if false {
		} else {
			h.decSliceCustomMetricCurrentStatus((*[]CustomMetricCurrentStatus)(yyv141), d)
		}
	}
	for {
		yyj140++
		if yyhl140 {
			yyb140 = yyj140 > l
		} else {
			yyb140 = r.CheckBreak()
		}
		if yyb140 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj140-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 {
		yym143 := z.EncBinary()
		_ = yym143
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep144 := !z.EncBinary()
			yy2arr144 := z.EncBasicHandle().StructToArray
			var yyq144 [5]bool
			_, _, _ = yysep144, yyq144, yy2arr144
			const yyr144 bool = false
			yyq144[0] = x.Kind != ""
			yyq144[1] = x.APIVersion != ""
			yyq144[2] = true
			yyq144[3] = x.Description != ""
			yyq144[4] = len(x.Versions) != 0
			var yynn144 int
			if yyr144 || yy2arr144 {
				r.EncodeArrayStart(5)
			} else {
				yynn144 = 0
				for _, b := range yyq144 {
					if b {
						yynn144++
					}
				}
				r.EncodeMapStart(yynn144)
				yynn144 = 0
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[0] {
					yym146 := z.EncBinary()
					_ = yym146
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym147 := z.EncBinary()
					_ = yym147
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[1] {
					yym149 := z.EncBinary()
					_ = yym149
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym150 := z.EncBinary()
					_ = yym150
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[2] {
					yy152 := &x.ObjectMeta
					yy152.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq144[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy153 := &x.ObjectMeta
					yy153.CodecEncodeSelf(e)
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[3] {
					yym155 := z.EncBinary()
					_ = yym155
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq144[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("description"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym156 := z.EncBinary()
					_ = yym156
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Description))
					}
				}
			}
			if yyr144 || yy2arr144 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq144[4] {
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym158 := z.EncBinary()
						_ = yym158
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq144[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("versions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Versions == nil {
						r.EncodeNil()
					} else {
						yym159 := z.EncBinary()
						_ = yym159
						if false {
						} else {
							h.encSliceAPIVersion(([]APIVersion)(x.Versions), e)
						}
					}
				}
			}
			if yyr144 || yy2arr144 {
				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
	yym160 := z.DecBinary()
	_ = yym160
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct161 := r.ContainerType()
		if yyct161 == codecSelferValueTypeMap1234 {
			yyl161 := r.ReadMapStart()
			if yyl161 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl161, d)
			}
		} else if yyct161 == codecSelferValueTypeArray1234 {
			yyl161 := r.ReadArrayStart()
			if yyl161 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl161, 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 yys162Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys162Slc
	var yyhl162 bool = l >= 0
	for yyj162 := 0; ; yyj162++ {
		if yyhl162 {
			if yyj162 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys162Slc = r.DecodeBytes(yys162Slc, true, true)
		yys162 := string(yys162Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys162 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv165 := &x.ObjectMeta
				yyv165.CodecDecodeSelf(d)
			}
		case "description":
			if r.TryDecodeAsNil() {
				x.Description = ""
			} else {
				x.Description = string(r.DecodeString())
			}
		case "versions":
			if r.TryDecodeAsNil() {
				x.Versions = nil
			} else {
				yyv167 := &x.Versions
				yym168 := z.DecBinary()
				_ = yym168
				if false {
				} else {
					h.decSliceAPIVersion((*[]APIVersion)(yyv167), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys162)
		} // end switch yys162
	} // end for yyj162
	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 yyj169 int
	var yyb169 bool
	var yyhl169 bool = l >= 0
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv172 := &x.ObjectMeta
		yyv172.CodecDecodeSelf(d)
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Description = ""
	} else {
		x.Description = string(r.DecodeString())
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Versions = nil
	} else {
		yyv174 := &x.Versions
		yym175 := z.DecBinary()
		_ = yym175
		if false {
		} else {
			h.decSliceAPIVersion((*[]APIVersion)(yyv174), d)
		}
	}
	for {
		yyj169++
		if yyhl169 {
			yyb169 = yyj169 > l
		} else {
			yyb169 = r.CheckBreak()
		}
		if yyb169 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj169-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 {
		yym176 := z.EncBinary()
		_ = yym176
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep177 := !z.EncBinary()
			yy2arr177 := z.EncBasicHandle().StructToArray
			var yyq177 [4]bool
			_, _, _ = yysep177, yyq177, yy2arr177
			const yyr177 bool = false
			yyq177[0] = x.Kind != ""
			yyq177[1] = x.APIVersion != ""
			yyq177[2] = true
			var yynn177 int
			if yyr177 || yy2arr177 {
				r.EncodeArrayStart(4)
			} else {
				yynn177 = 1
				for _, b := range yyq177 {
					if b {
						yynn177++
					}
				}
				r.EncodeMapStart(yynn177)
				yynn177 = 0
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[0] {
					yym179 := z.EncBinary()
					_ = yym179
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq177[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym180 := z.EncBinary()
					_ = yym180
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[1] {
					yym182 := z.EncBinary()
					_ = yym182
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq177[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym183 := z.EncBinary()
					_ = yym183
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq177[2] {
					yy185 := &x.ListMeta
					yym186 := z.EncBinary()
					_ = yym186
					if false {
					} else if z.HasExtensions() && z.EncExt(yy185) {
					} else {
						z.EncFallback(yy185)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq177[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy187 := &x.ListMeta
					yym188 := z.EncBinary()
					_ = yym188
					if false {
					} else if z.HasExtensions() && z.EncExt(yy187) {
					} else {
						z.EncFallback(yy187)
					}
				}
			}
			if yyr177 || yy2arr177 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym190 := z.EncBinary()
					_ = yym190
					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 {
					yym191 := z.EncBinary()
					_ = yym191
					if false {
					} else {
						h.encSliceThirdPartyResource(([]ThirdPartyResource)(x.Items), e)
					}
				}
			}
			if yyr177 || yy2arr177 {
				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
	yym192 := z.DecBinary()
	_ = yym192
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct193 := r.ContainerType()
		if yyct193 == codecSelferValueTypeMap1234 {
			yyl193 := r.ReadMapStart()
			if yyl193 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl193, d)
			}
		} else if yyct193 == codecSelferValueTypeArray1234 {
			yyl193 := r.ReadArrayStart()
			if yyl193 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl193, 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 yys194Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys194Slc
	var yyhl194 bool = l >= 0
	for yyj194 := 0; ; yyj194++ {
		if yyhl194 {
			if yyj194 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys194Slc = r.DecodeBytes(yys194Slc, true, true)
		yys194 := string(yys194Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys194 {
		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 {
				yyv197 := &x.ListMeta
				yym198 := z.DecBinary()
				_ = yym198
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv197) {
				} else {
					z.DecFallback(yyv197, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv199 := &x.Items
				yym200 := z.DecBinary()
				_ = yym200
				if false {
				} else {
					h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv199), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys194)
		} // end switch yys194
	} // end for yyj194
	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 yyj201 int
	var yyb201 bool
	var yyhl201 bool = l >= 0
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv204 := &x.ListMeta
		yym205 := z.DecBinary()
		_ = yym205
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv204) {
		} else {
			z.DecFallback(yyv204, false)
		}
	}
	yyj201++
	if yyhl201 {
		yyb201 = yyj201 > l
	} else {
		yyb201 = r.CheckBreak()
	}
	if yyb201 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv206 := &x.Items
		yym207 := z.DecBinary()
		_ = yym207
		if false {
		} else {
			h.decSliceThirdPartyResource((*[]ThirdPartyResource)(yyv206), d)
		}
	}
	for {
		yyj201++
		if yyhl201 {
			yyb201 = yyj201 > l
		} else {
			yyb201 = r.CheckBreak()
		}
		if yyb201 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj201-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 {
		yym208 := z.EncBinary()
		_ = yym208
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep209 := !z.EncBinary()
			yy2arr209 := z.EncBasicHandle().StructToArray
			var yyq209 [1]bool
			_, _, _ = yysep209, yyq209, yy2arr209
			const yyr209 bool = false
			yyq209[0] = x.Name != ""
			var yynn209 int
			if yyr209 || yy2arr209 {
				r.EncodeArrayStart(1)
			} else {
				yynn209 = 0
				for _, b := range yyq209 {
					if b {
						yynn209++
					}
				}
				r.EncodeMapStart(yynn209)
				yynn209 = 0
			}
			if yyr209 || yy2arr209 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq209[0] {
					yym211 := z.EncBinary()
					_ = yym211
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq209[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym212 := z.EncBinary()
					_ = yym212
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr209 || yy2arr209 {
				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
	yym213 := z.DecBinary()
	_ = yym213
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct214 := r.ContainerType()
		if yyct214 == codecSelferValueTypeMap1234 {
			yyl214 := r.ReadMapStart()
			if yyl214 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl214, d)
			}
		} else if yyct214 == codecSelferValueTypeArray1234 {
			yyl214 := r.ReadArrayStart()
			if yyl214 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl214, 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 yys215Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys215Slc
	var yyhl215 bool = l >= 0
	for yyj215 := 0; ; yyj215++ {
		if yyhl215 {
			if yyj215 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys215Slc = r.DecodeBytes(yys215Slc, true, true)
		yys215 := string(yys215Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys215 {
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys215)
		} // end switch yys215
	} // end for yyj215
	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 yyj217 int
	var yyb217 bool
	var yyhl217 bool = l >= 0
	yyj217++
	if yyhl217 {
		yyb217 = yyj217 > l
	} else {
		yyb217 = r.CheckBreak()
	}
	if yyb217 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	for {
		yyj217++
		if yyhl217 {
			yyb217 = yyj217 > l
		} else {
			yyb217 = r.CheckBreak()
		}
		if yyb217 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj217-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 {
		yym219 := z.EncBinary()
		_ = yym219
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep220 := !z.EncBinary()
			yy2arr220 := z.EncBasicHandle().StructToArray
			var yyq220 [4]bool
			_, _, _ = yysep220, yyq220, yy2arr220
			const yyr220 bool = false
			yyq220[0] = x.Kind != ""
			yyq220[1] = x.APIVersion != ""
			yyq220[2] = true
			yyq220[3] = len(x.Data) != 0
			var yynn220 int
			if yyr220 || yy2arr220 {
				r.EncodeArrayStart(4)
			} else {
				yynn220 = 0
				for _, b := range yyq220 {
					if b {
						yynn220++
					}
				}
				r.EncodeMapStart(yynn220)
				yynn220 = 0
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[0] {
					yym222 := z.EncBinary()
					_ = yym222
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym223 := z.EncBinary()
					_ = yym223
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[1] {
					yym225 := z.EncBinary()
					_ = yym225
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq220[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym226 := z.EncBinary()
					_ = yym226
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[2] {
					yy228 := &x.ObjectMeta
					yy228.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq220[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy229 := &x.ObjectMeta
					yy229.CodecEncodeSelf(e)
				}
			}
			if yyr220 || yy2arr220 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq220[3] {
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym231 := z.EncBinary()
						_ = yym231
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq220[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("data"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Data == nil {
						r.EncodeNil()
					} else {
						yym232 := z.EncBinary()
						_ = yym232
						if false {
						} else {
							r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
						}
					}
				}
			}
			if yyr220 || yy2arr220 {
				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
	yym233 := z.DecBinary()
	_ = yym233
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct234 := r.ContainerType()
		if yyct234 == codecSelferValueTypeMap1234 {
			yyl234 := r.ReadMapStart()
			if yyl234 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl234, d)
			}
		} else if yyct234 == codecSelferValueTypeArray1234 {
			yyl234 := r.ReadArrayStart()
			if yyl234 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl234, 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 yys235Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys235Slc
	var yyhl235 bool = l >= 0
	for yyj235 := 0; ; yyj235++ {
		if yyhl235 {
			if yyj235 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys235Slc = r.DecodeBytes(yys235Slc, true, true)
		yys235 := string(yys235Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys235 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv238 := &x.ObjectMeta
				yyv238.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv239 := &x.Data
				yym240 := z.DecBinary()
				_ = yym240
				if false {
				} else {
					*yyv239 = r.DecodeBytes(*(*[]byte)(yyv239), false, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys235)
		} // end switch yys235
	} // end for yyj235
	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 yyj241 int
	var yyb241 bool
	var yyhl241 bool = l >= 0
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv244 := &x.ObjectMeta
		yyv244.CodecDecodeSelf(d)
	}
	yyj241++
	if yyhl241 {
		yyb241 = yyj241 > l
	} else {
		yyb241 = r.CheckBreak()
	}
	if yyb241 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv245 := &x.Data
		yym246 := z.DecBinary()
		_ = yym246
		if false {
		} else {
			*yyv245 = r.DecodeBytes(*(*[]byte)(yyv245), false, false)
		}
	}
	for {
		yyj241++
		if yyhl241 {
			yyb241 = yyj241 > l
		} else {
			yyb241 = r.CheckBreak()
		}
		if yyb241 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj241-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 {
		yym247 := z.EncBinary()
		_ = yym247
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep248 := !z.EncBinary()
			yy2arr248 := z.EncBasicHandle().StructToArray
			var yyq248 [5]bool
			_, _, _ = yysep248, yyq248, yy2arr248
			const yyr248 bool = false
			yyq248[0] = x.Kind != ""
			yyq248[1] = x.APIVersion != ""
			yyq248[2] = true
			yyq248[3] = true
			yyq248[4] = true
			var yynn248 int
			if yyr248 || yy2arr248 {
				r.EncodeArrayStart(5)
			} else {
				yynn248 = 0
				for _, b := range yyq248 {
					if b {
						yynn248++
					}
				}
				r.EncodeMapStart(yynn248)
				yynn248 = 0
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[0] {
					yym250 := z.EncBinary()
					_ = yym250
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq248[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym251 := z.EncBinary()
					_ = yym251
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[1] {
					yym253 := z.EncBinary()
					_ = yym253
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq248[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym254 := z.EncBinary()
					_ = yym254
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[2] {
					yy256 := &x.ObjectMeta
					yy256.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy257 := &x.ObjectMeta
					yy257.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[3] {
					yy259 := &x.Spec
					yy259.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy260 := &x.Spec
					yy260.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq248[4] {
					yy262 := &x.Status
					yy262.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq248[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy263 := &x.Status
					yy263.CodecEncodeSelf(e)
				}
			}
			if yyr248 || yy2arr248 {
				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
	yym264 := z.DecBinary()
	_ = yym264
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct265 := r.ContainerType()
		if yyct265 == codecSelferValueTypeMap1234 {
			yyl265 := r.ReadMapStart()
			if yyl265 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl265, d)
			}
		} else if yyct265 == codecSelferValueTypeArray1234 {
			yyl265 := r.ReadArrayStart()
			if yyl265 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl265, 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 yys266Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys266Slc
	var yyhl266 bool = l >= 0
	for yyj266 := 0; ; yyj266++ {
		if yyhl266 {
			if yyj266 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys266Slc = r.DecodeBytes(yys266Slc, true, true)
		yys266 := string(yys266Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys266 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv269 := &x.ObjectMeta
				yyv269.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DeploymentSpec{}
			} else {
				yyv270 := &x.Spec
				yyv270.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DeploymentStatus{}
			} else {
				yyv271 := &x.Status
				yyv271.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys266)
		} // end switch yys266
	} // end for yyj266
	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 yyj272 int
	var yyb272 bool
	var yyhl272 bool = l >= 0
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv275 := &x.ObjectMeta
		yyv275.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DeploymentSpec{}
	} else {
		yyv276 := &x.Spec
		yyv276.CodecDecodeSelf(d)
	}
	yyj272++
	if yyhl272 {
		yyb272 = yyj272 > l
	} else {
		yyb272 = r.CheckBreak()
	}
	if yyb272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DeploymentStatus{}
	} else {
		yyv277 := &x.Status
		yyv277.CodecDecodeSelf(d)
	}
	for {
		yyj272++
		if yyhl272 {
			yyb272 = yyj272 > l
		} else {
			yyb272 = r.CheckBreak()
		}
		if yyb272 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj272-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 {
		yym278 := z.EncBinary()
		_ = yym278
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep279 := !z.EncBinary()
			yy2arr279 := z.EncBasicHandle().StructToArray
			var yyq279 [8]bool
			_, _, _ = yysep279, yyq279, yy2arr279
			const yyr279 bool = false
			yyq279[0] = x.Replicas != 0
			yyq279[1] = x.Selector != nil
			yyq279[3] = true
			yyq279[4] = x.MinReadySeconds != 0
			yyq279[5] = x.RevisionHistoryLimit != nil
			yyq279[6] = x.Paused != false
			yyq279[7] = x.RollbackTo != nil
			var yynn279 int
			if yyr279 || yy2arr279 {
				r.EncodeArrayStart(8)
			} else {
				yynn279 = 1
				for _, b := range yyq279 {
					if b {
						yynn279++
					}
				}
				r.EncodeMapStart(yynn279)
				yynn279 = 0
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[0] {
					yym281 := z.EncBinary()
					_ = yym281
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq279[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym282 := z.EncBinary()
					_ = yym282
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[1] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym284 := z.EncBinary()
						_ = yym284
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym285 := z.EncBinary()
						_ = yym285
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy287 := &x.Template
				yy287.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy288 := &x.Template
				yy288.CodecEncodeSelf(e)
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[3] {
					yy290 := &x.Strategy
					yy290.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("strategy"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy291 := &x.Strategy
					yy291.CodecEncodeSelf(e)
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[4] {
					yym293 := z.EncBinary()
					_ = yym293
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq279[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym294 := z.EncBinary()
					_ = yym294
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[5] {
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy296 := *x.RevisionHistoryLimit
						yym297 := z.EncBinary()
						_ = yym297
						if false {
						} else {
							r.EncodeInt(int64(yy296))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revisionHistoryLimit"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RevisionHistoryLimit == nil {
						r.EncodeNil()
					} else {
						yy298 := *x.RevisionHistoryLimit
						yym299 := z.EncBinary()
						_ = yym299
						if false {
						} else {
							r.EncodeInt(int64(yy298))
						}
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[6] {
					yym301 := z.EncBinary()
					_ = yym301
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq279[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("paused"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym302 := z.EncBinary()
					_ = yym302
					if false {
					} else {
						r.EncodeBool(bool(x.Paused))
					}
				}
			}
			if yyr279 || yy2arr279 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq279[7] {
					if x.RollbackTo == nil {
						r.EncodeNil()
					} else {
						x.RollbackTo.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq279[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 yyr279 || yy2arr279 {
				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
	yym304 := z.DecBinary()
	_ = yym304
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct305 := r.ContainerType()
		if yyct305 == codecSelferValueTypeMap1234 {
			yyl305 := r.ReadMapStart()
			if yyl305 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl305, d)
			}
		} else if yyct305 == codecSelferValueTypeArray1234 {
			yyl305 := r.ReadArrayStart()
			if yyl305 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl305, 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 yys306Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys306Slc
	var yyhl306 bool = l >= 0
	for yyj306 := 0; ; yyj306++ {
		if yyhl306 {
			if yyj306 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys306Slc = r.DecodeBytes(yys306Slc, true, true)
		yys306 := string(yys306Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys306 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				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(pkg1_unversioned.LabelSelector)
				}
				yym309 := z.DecBinary()
				_ = yym309
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv310 := &x.Template
				yyv310.CodecDecodeSelf(d)
			}
		case "strategy":
			if r.TryDecodeAsNil() {
				x.Strategy = DeploymentStrategy{}
			} else {
				yyv311 := &x.Strategy
				yyv311.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)
				}
				yym314 := z.DecBinary()
				_ = yym314
				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, yys306)
		} // end switch yys306
	} // end for yyj306
	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 yyj317 int
	var yyb317 bool
	var yyhl317 bool = l >= 0
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym320 := z.DecBinary()
		_ = yym320
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv321 := &x.Template
		yyv321.CodecDecodeSelf(d)
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Strategy = DeploymentStrategy{}
	} else {
		yyv322 := &x.Strategy
		yyv322.CodecDecodeSelf(d)
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		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)
		}
		yym325 := z.DecBinary()
		_ = yym325
		if false {
		} else {
			*((*int32)(x.RevisionHistoryLimit)) = int32(r.DecodeInt(32))
		}
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paused = false
	} else {
		x.Paused = bool(r.DecodeBool())
	}
	yyj317++
	if yyhl317 {
		yyb317 = yyj317 > l
	} else {
		yyb317 = r.CheckBreak()
	}
	if yyb317 {
		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 {
		yyj317++
		if yyhl317 {
			yyb317 = yyj317 > l
		} else {
			yyb317 = r.CheckBreak()
		}
		if yyb317 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj317-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 {
		yym328 := z.EncBinary()
		_ = yym328
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep329 := !z.EncBinary()
			yy2arr329 := z.EncBasicHandle().StructToArray
			var yyq329 [5]bool
			_, _, _ = yysep329, yyq329, yy2arr329
			const yyr329 bool = false
			yyq329[0] = x.Kind != ""
			yyq329[1] = x.APIVersion != ""
			yyq329[3] = len(x.UpdatedAnnotations) != 0
			var yynn329 int
			if yyr329 || yy2arr329 {
				r.EncodeArrayStart(5)
			} else {
				yynn329 = 2
				for _, b := range yyq329 {
					if b {
						yynn329++
					}
				}
				r.EncodeMapStart(yynn329)
				yynn329 = 0
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[0] {
					yym331 := z.EncBinary()
					_ = yym331
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq329[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym332 := z.EncBinary()
					_ = yym332
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[1] {
					yym334 := z.EncBinary()
					_ = yym334
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq329[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym335 := z.EncBinary()
					_ = yym335
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym337 := z.EncBinary()
				_ = yym337
				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)
				yym338 := z.EncBinary()
				_ = yym338
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Name))
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq329[3] {
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym340 := z.EncBinary()
						_ = yym340
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq329[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedAnnotations"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.UpdatedAnnotations == nil {
						r.EncodeNil()
					} else {
						yym341 := z.EncBinary()
						_ = yym341
						if false {
						} else {
							z.F.EncMapStringStringV(x.UpdatedAnnotations, false, e)
						}
					}
				}
			}
			if yyr329 || yy2arr329 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy343 := &x.RollbackTo
				yy343.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("rollbackTo"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy344 := &x.RollbackTo
				yy344.CodecEncodeSelf(e)
			}
			if yyr329 || yy2arr329 {
				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
	yym345 := z.DecBinary()
	_ = yym345
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct346 := r.ContainerType()
		if yyct346 == codecSelferValueTypeMap1234 {
			yyl346 := r.ReadMapStart()
			if yyl346 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl346, d)
			}
		} else if yyct346 == codecSelferValueTypeArray1234 {
			yyl346 := r.ReadArrayStart()
			if yyl346 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl346, 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 yys347Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys347Slc
	var yyhl347 bool = l >= 0
	for yyj347 := 0; ; yyj347++ {
		if yyhl347 {
			if yyj347 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys347Slc = r.DecodeBytes(yys347Slc, true, true)
		yys347 := string(yys347Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys347 {
		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 {
				yyv351 := &x.UpdatedAnnotations
				yym352 := z.DecBinary()
				_ = yym352
				if false {
				} else {
					z.F.DecMapStringStringX(yyv351, false, d)
				}
			}
		case "rollbackTo":
			if r.TryDecodeAsNil() {
				x.RollbackTo = RollbackConfig{}
			} else {
				yyv353 := &x.RollbackTo
				yyv353.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys347)
		} // end switch yys347
	} // end for yyj347
	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 yyj354 int
	var yyb354 bool
	var yyhl354 bool = l >= 0
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedAnnotations = nil
	} else {
		yyv358 := &x.UpdatedAnnotations
		yym359 := z.DecBinary()
		_ = yym359
		if false {
		} else {
			z.F.DecMapStringStringX(yyv358, false, d)
		}
	}
	yyj354++
	if yyhl354 {
		yyb354 = yyj354 > l
	} else {
		yyb354 = r.CheckBreak()
	}
	if yyb354 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RollbackTo = RollbackConfig{}
	} else {
		yyv360 := &x.RollbackTo
		yyv360.CodecDecodeSelf(d)
	}
	for {
		yyj354++
		if yyhl354 {
			yyb354 = yyj354 > l
		} else {
			yyb354 = r.CheckBreak()
		}
		if yyb354 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj354-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 {
		yym361 := z.EncBinary()
		_ = yym361
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep362 := !z.EncBinary()
			yy2arr362 := z.EncBasicHandle().StructToArray
			var yyq362 [1]bool
			_, _, _ = yysep362, yyq362, yy2arr362
			const yyr362 bool = false
			yyq362[0] = x.Revision != 0
			var yynn362 int
			if yyr362 || yy2arr362 {
				r.EncodeArrayStart(1)
			} else {
				yynn362 = 0
				for _, b := range yyq362 {
					if b {
						yynn362++
					}
				}
				r.EncodeMapStart(yynn362)
				yynn362 = 0
			}
			if yyr362 || yy2arr362 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq362[0] {
					yym364 := z.EncBinary()
					_ = yym364
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq362[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("revision"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym365 := z.EncBinary()
					_ = yym365
					if false {
					} else {
						r.EncodeInt(int64(x.Revision))
					}
				}
			}
			if yyr362 || yy2arr362 {
				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
	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 *RollbackConfig) 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 "revision":
			if r.TryDecodeAsNil() {
				x.Revision = 0
			} else {
				x.Revision = int64(r.DecodeInt(64))
			}
		default:
			z.DecStructFieldNotFound(-1, yys368)
		} // end switch yys368
	} // end for yyj368
	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 yyj370 int
	var yyb370 bool
	var yyhl370 bool = l >= 0
	yyj370++
	if yyhl370 {
		yyb370 = yyj370 > l
	} else {
		yyb370 = r.CheckBreak()
	}
	if yyb370 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Revision = 0
	} else {
		x.Revision = int64(r.DecodeInt(64))
	}
	for {
		yyj370++
		if yyhl370 {
			yyb370 = yyj370 > l
		} else {
			yyb370 = r.CheckBreak()
		}
		if yyb370 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj370-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 {
		yym372 := z.EncBinary()
		_ = yym372
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep373 := !z.EncBinary()
			yy2arr373 := z.EncBasicHandle().StructToArray
			var yyq373 [2]bool
			_, _, _ = yysep373, yyq373, yy2arr373
			const yyr373 bool = false
			yyq373[0] = x.Type != ""
			yyq373[1] = x.RollingUpdate != nil
			var yynn373 int
			if yyr373 || yy2arr373 {
				r.EncodeArrayStart(2)
			} else {
				yynn373 = 0
				for _, b := range yyq373 {
					if b {
						yynn373++
					}
				}
				r.EncodeMapStart(yynn373)
				yynn373 = 0
			}
			if yyr373 || yy2arr373 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq373[0] {
					x.Type.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq373[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("type"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Type.CodecEncodeSelf(e)
				}
			}
			if yyr373 || yy2arr373 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq373[1] {
					if x.RollingUpdate == nil {
						r.EncodeNil()
					} else {
						x.RollingUpdate.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq373[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 yyr373 || yy2arr373 {
				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
	yym376 := z.DecBinary()
	_ = yym376
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct377 := r.ContainerType()
		if yyct377 == codecSelferValueTypeMap1234 {
			yyl377 := r.ReadMapStart()
			if yyl377 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl377, d)
			}
		} else if yyct377 == codecSelferValueTypeArray1234 {
			yyl377 := r.ReadArrayStart()
			if yyl377 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl377, 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 yys378Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys378Slc
	var yyhl378 bool = l >= 0
	for yyj378 := 0; ; yyj378++ {
		if yyhl378 {
			if yyj378 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys378Slc = r.DecodeBytes(yys378Slc, true, true)
		yys378 := string(yys378Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys378 {
		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, yys378)
		} // end switch yys378
	} // end for yyj378
	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 yyj381 int
	var yyb381 bool
	var yyhl381 bool = l >= 0
	yyj381++
	if yyhl381 {
		yyb381 = yyj381 > l
	} else {
		yyb381 = r.CheckBreak()
	}
	if yyb381 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = DeploymentStrategyType(r.DecodeString())
	}
	yyj381++
	if yyhl381 {
		yyb381 = yyj381 > l
	} else {
		yyb381 = r.CheckBreak()
	}
	if yyb381 {
		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 {
		yyj381++
		if yyhl381 {
			yyb381 = yyj381 > l
		} else {
			yyb381 = r.CheckBreak()
		}
		if yyb381 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj381-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x DeploymentStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym384 := z.EncBinary()
	_ = yym384
	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
	yym385 := z.DecBinary()
	_ = yym385
	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 {
		yym386 := z.EncBinary()
		_ = yym386
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep387 := !z.EncBinary()
			yy2arr387 := z.EncBasicHandle().StructToArray
			var yyq387 [2]bool
			_, _, _ = yysep387, yyq387, yy2arr387
			const yyr387 bool = false
			yyq387[0] = true
			yyq387[1] = true
			var yynn387 int
			if yyr387 || yy2arr387 {
				r.EncodeArrayStart(2)
			} else {
				yynn387 = 0
				for _, b := range yyq387 {
					if b {
						yynn387++
					}
				}
				r.EncodeMapStart(yynn387)
				yynn387 = 0
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[0] {
					yy389 := &x.MaxUnavailable
					yym390 := z.EncBinary()
					_ = yym390
					if false {
					} else if z.HasExtensions() && z.EncExt(yy389) {
					} else if !yym390 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy389)
					} else {
						z.EncFallback(yy389)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxUnavailable"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy391 := &x.MaxUnavailable
					yym392 := z.EncBinary()
					_ = yym392
					if false {
					} else if z.HasExtensions() && z.EncExt(yy391) {
					} else if !yym392 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy391)
					} else {
						z.EncFallback(yy391)
					}
				}
			}
			if yyr387 || yy2arr387 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq387[1] {
					yy394 := &x.MaxSurge
					yym395 := z.EncBinary()
					_ = yym395
					if false {
					} else if z.HasExtensions() && z.EncExt(yy394) {
					} else if !yym395 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy394)
					} else {
						z.EncFallback(yy394)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq387[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("maxSurge"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy396 := &x.MaxSurge
					yym397 := z.EncBinary()
					_ = yym397
					if false {
					} else if z.HasExtensions() && z.EncExt(yy396) {
					} else if !yym397 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy396)
					} else {
						z.EncFallback(yy396)
					}
				}
			}
			if yyr387 || yy2arr387 {
				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
	yym398 := z.DecBinary()
	_ = yym398
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct399 := r.ContainerType()
		if yyct399 == codecSelferValueTypeMap1234 {
			yyl399 := r.ReadMapStart()
			if yyl399 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl399, d)
			}
		} else if yyct399 == codecSelferValueTypeArray1234 {
			yyl399 := r.ReadArrayStart()
			if yyl399 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl399, 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 yys400Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys400Slc
	var yyhl400 bool = l >= 0
	for yyj400 := 0; ; yyj400++ {
		if yyhl400 {
			if yyj400 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys400Slc = r.DecodeBytes(yys400Slc, true, true)
		yys400 := string(yys400Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys400 {
		case "maxUnavailable":
			if r.TryDecodeAsNil() {
				x.MaxUnavailable = pkg5_intstr.IntOrString{}
			} else {
				yyv401 := &x.MaxUnavailable
				yym402 := z.DecBinary()
				_ = yym402
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv401) {
				} else if !yym402 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv401)
				} else {
					z.DecFallback(yyv401, false)
				}
			}
		case "maxSurge":
			if r.TryDecodeAsNil() {
				x.MaxSurge = pkg5_intstr.IntOrString{}
			} else {
				yyv403 := &x.MaxSurge
				yym404 := z.DecBinary()
				_ = yym404
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv403) {
				} else if !yym404 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv403)
				} else {
					z.DecFallback(yyv403, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys400)
		} // end switch yys400
	} // end for yyj400
	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 yyj405 int
	var yyb405 bool
	var yyhl405 bool = l >= 0
	yyj405++
	if yyhl405 {
		yyb405 = yyj405 > l
	} else {
		yyb405 = r.CheckBreak()
	}
	if yyb405 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxUnavailable = pkg5_intstr.IntOrString{}
	} else {
		yyv406 := &x.MaxUnavailable
		yym407 := z.DecBinary()
		_ = yym407
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv406) {
		} else if !yym407 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv406)
		} else {
			z.DecFallback(yyv406, false)
		}
	}
	yyj405++
	if yyhl405 {
		yyb405 = yyj405 > l
	} else {
		yyb405 = r.CheckBreak()
	}
	if yyb405 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MaxSurge = pkg5_intstr.IntOrString{}
	} else {
		yyv408 := &x.MaxSurge
		yym409 := z.DecBinary()
		_ = yym409
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv408) {
		} else if !yym409 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv408)
		} else {
			z.DecFallback(yyv408, false)
		}
	}
	for {
		yyj405++
		if yyhl405 {
			yyb405 = yyj405 > l
		} else {
			yyb405 = r.CheckBreak()
		}
		if yyb405 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj405-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 {
		yym410 := z.EncBinary()
		_ = yym410
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep411 := !z.EncBinary()
			yy2arr411 := z.EncBasicHandle().StructToArray
			var yyq411 [5]bool
			_, _, _ = yysep411, yyq411, yy2arr411
			const yyr411 bool = false
			yyq411[0] = x.ObservedGeneration != 0
			yyq411[1] = x.Replicas != 0
			yyq411[2] = x.UpdatedReplicas != 0
			yyq411[3] = x.AvailableReplicas != 0
			yyq411[4] = x.UnavailableReplicas != 0
			var yynn411 int
			if yyr411 || yy2arr411 {
				r.EncodeArrayStart(5)
			} else {
				yynn411 = 0
				for _, b := range yyq411 {
					if b {
						yynn411++
					}
				}
				r.EncodeMapStart(yynn411)
				yynn411 = 0
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[0] {
					yym413 := z.EncBinary()
					_ = yym413
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym414 := z.EncBinary()
					_ = yym414
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[1] {
					yym416 := z.EncBinary()
					_ = yym416
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("replicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym417 := z.EncBinary()
					_ = yym417
					if false {
					} else {
						r.EncodeInt(int64(x.Replicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[2] {
					yym419 := z.EncBinary()
					_ = yym419
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("updatedReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym420 := z.EncBinary()
					_ = yym420
					if false {
					} else {
						r.EncodeInt(int64(x.UpdatedReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[3] {
					yym422 := z.EncBinary()
					_ = yym422
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym423 := z.EncBinary()
					_ = yym423
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq411[4] {
					yym425 := z.EncBinary()
					_ = yym425
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq411[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("unavailableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym426 := z.EncBinary()
					_ = yym426
					if false {
					} else {
						r.EncodeInt(int64(x.UnavailableReplicas))
					}
				}
			}
			if yyr411 || yy2arr411 {
				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
	yym427 := z.DecBinary()
	_ = yym427
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct428 := r.ContainerType()
		if yyct428 == codecSelferValueTypeMap1234 {
			yyl428 := r.ReadMapStart()
			if yyl428 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl428, d)
			}
		} else if yyct428 == codecSelferValueTypeArray1234 {
			yyl428 := r.ReadArrayStart()
			if yyl428 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl428, 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 yys429Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys429Slc
	var yyhl429 bool = l >= 0
	for yyj429 := 0; ; yyj429++ {
		if yyhl429 {
			if yyj429 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys429Slc = r.DecodeBytes(yys429Slc, true, true)
		yys429 := string(yys429Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys429 {
		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, yys429)
		} // end switch yys429
	} // end for yyj429
	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 yyj435 int
	var yyb435 bool
	var yyhl435 bool = l >= 0
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UpdatedReplicas = 0
	} else {
		x.UpdatedReplicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj435++
	if yyhl435 {
		yyb435 = yyj435 > l
	} else {
		yyb435 = r.CheckBreak()
	}
	if yyb435 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.UnavailableReplicas = 0
	} else {
		x.UnavailableReplicas = int32(r.DecodeInt(32))
	}
	for {
		yyj435++
		if yyhl435 {
			yyb435 = yyj435 > l
		} else {
			yyb435 = r.CheckBreak()
		}
		if yyb435 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj435-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 {
		yym441 := z.EncBinary()
		_ = yym441
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep442 := !z.EncBinary()
			yy2arr442 := z.EncBasicHandle().StructToArray
			var yyq442 [4]bool
			_, _, _ = yysep442, yyq442, yy2arr442
			const yyr442 bool = false
			yyq442[0] = x.Kind != ""
			yyq442[1] = x.APIVersion != ""
			yyq442[2] = true
			var yynn442 int
			if yyr442 || yy2arr442 {
				r.EncodeArrayStart(4)
			} else {
				yynn442 = 1
				for _, b := range yyq442 {
					if b {
						yynn442++
					}
				}
				r.EncodeMapStart(yynn442)
				yynn442 = 0
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[0] {
					yym444 := z.EncBinary()
					_ = yym444
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq442[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym445 := z.EncBinary()
					_ = yym445
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[1] {
					yym447 := z.EncBinary()
					_ = yym447
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq442[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym448 := z.EncBinary()
					_ = yym448
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq442[2] {
					yy450 := &x.ListMeta
					yym451 := z.EncBinary()
					_ = yym451
					if false {
					} else if z.HasExtensions() && z.EncExt(yy450) {
					} else {
						z.EncFallback(yy450)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq442[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy452 := &x.ListMeta
					yym453 := z.EncBinary()
					_ = yym453
					if false {
					} else if z.HasExtensions() && z.EncExt(yy452) {
					} else {
						z.EncFallback(yy452)
					}
				}
			}
			if yyr442 || yy2arr442 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym455 := z.EncBinary()
					_ = yym455
					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 {
					yym456 := z.EncBinary()
					_ = yym456
					if false {
					} else {
						h.encSliceDeployment(([]Deployment)(x.Items), e)
					}
				}
			}
			if yyr442 || yy2arr442 {
				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
	yym457 := z.DecBinary()
	_ = yym457
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct458 := r.ContainerType()
		if yyct458 == codecSelferValueTypeMap1234 {
			yyl458 := r.ReadMapStart()
			if yyl458 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl458, d)
			}
		} else if yyct458 == codecSelferValueTypeArray1234 {
			yyl458 := r.ReadArrayStart()
			if yyl458 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl458, 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 yys459Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys459Slc
	var yyhl459 bool = l >= 0
	for yyj459 := 0; ; yyj459++ {
		if yyhl459 {
			if yyj459 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys459Slc = r.DecodeBytes(yys459Slc, true, true)
		yys459 := string(yys459Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys459 {
		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 {
				yyv462 := &x.ListMeta
				yym463 := z.DecBinary()
				_ = yym463
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv462) {
				} else {
					z.DecFallback(yyv462, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv464 := &x.Items
				yym465 := z.DecBinary()
				_ = yym465
				if false {
				} else {
					h.decSliceDeployment((*[]Deployment)(yyv464), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys459)
		} // end switch yys459
	} // end for yyj459
	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 yyj466 int
	var yyb466 bool
	var yyhl466 bool = l >= 0
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv469 := &x.ListMeta
		yym470 := z.DecBinary()
		_ = yym470
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv469) {
		} else {
			z.DecFallback(yyv469, false)
		}
	}
	yyj466++
	if yyhl466 {
		yyb466 = yyj466 > l
	} else {
		yyb466 = r.CheckBreak()
	}
	if yyb466 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv471 := &x.Items
		yym472 := z.DecBinary()
		_ = yym472
		if false {
		} else {
			h.decSliceDeployment((*[]Deployment)(yyv471), d)
		}
	}
	for {
		yyj466++
		if yyhl466 {
			yyb466 = yyj466 > l
		} else {
			yyb466 = r.CheckBreak()
		}
		if yyb466 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj466-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 {
		yym473 := z.EncBinary()
		_ = yym473
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep474 := !z.EncBinary()
			yy2arr474 := z.EncBasicHandle().StructToArray
			var yyq474 [2]bool
			_, _, _ = yysep474, yyq474, yy2arr474
			const yyr474 bool = false
			yyq474[0] = x.Selector != nil
			var yynn474 int
			if yyr474 || yy2arr474 {
				r.EncodeArrayStart(2)
			} else {
				yynn474 = 1
				for _, b := range yyq474 {
					if b {
						yynn474++
					}
				}
				r.EncodeMapStart(yynn474)
				yynn474 = 0
			}
			if yyr474 || yy2arr474 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq474[0] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym476 := z.EncBinary()
						_ = yym476
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq474[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym477 := z.EncBinary()
						_ = yym477
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr474 || yy2arr474 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy479 := &x.Template
				yy479.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("template"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy480 := &x.Template
				yy480.CodecEncodeSelf(e)
			}
			if yyr474 || yy2arr474 {
				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
	yym481 := z.DecBinary()
	_ = yym481
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct482 := r.ContainerType()
		if yyct482 == codecSelferValueTypeMap1234 {
			yyl482 := r.ReadMapStart()
			if yyl482 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl482, d)
			}
		} else if yyct482 == codecSelferValueTypeArray1234 {
			yyl482 := r.ReadArrayStart()
			if yyl482 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl482, 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 yys483Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys483Slc
	var yyhl483 bool = l >= 0
	for yyj483 := 0; ; yyj483++ {
		if yyhl483 {
			if yyj483 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys483Slc = r.DecodeBytes(yys483Slc, true, true)
		yys483 := string(yys483Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys483 {
		case "selector":
			if r.TryDecodeAsNil() {
				if x.Selector != nil {
					x.Selector = nil
				}
			} else {
				if x.Selector == nil {
					x.Selector = new(pkg1_unversioned.LabelSelector)
				}
				yym485 := z.DecBinary()
				_ = yym485
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv486 := &x.Template
				yyv486.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys483)
		} // end switch yys483
	} // end for yyj483
	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 yyj487 int
	var yyb487 bool
	var yyhl487 bool = l >= 0
	yyj487++
	if yyhl487 {
		yyb487 = yyj487 > l
	} else {
		yyb487 = r.CheckBreak()
	}
	if yyb487 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym489 := z.DecBinary()
		_ = yym489
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj487++
	if yyhl487 {
		yyb487 = yyj487 > l
	} else {
		yyb487 = r.CheckBreak()
	}
	if yyb487 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv490 := &x.Template
		yyv490.CodecDecodeSelf(d)
	}
	for {
		yyj487++
		if yyhl487 {
			yyb487 = yyj487 > l
		} else {
			yyb487 = r.CheckBreak()
		}
		if yyb487 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj487-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 {
		yym491 := z.EncBinary()
		_ = yym491
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep492 := !z.EncBinary()
			yy2arr492 := z.EncBasicHandle().StructToArray
			var yyq492 [4]bool
			_, _, _ = yysep492, yyq492, yy2arr492
			const yyr492 bool = false
			var yynn492 int
			if yyr492 || yy2arr492 {
				r.EncodeArrayStart(4)
			} else {
				yynn492 = 4
				for _, b := range yyq492 {
					if b {
						yynn492++
					}
				}
				r.EncodeMapStart(yynn492)
				yynn492 = 0
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym494 := z.EncBinary()
				_ = yym494
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("currentNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym495 := z.EncBinary()
				_ = yym495
				if false {
				} else {
					r.EncodeInt(int64(x.CurrentNumberScheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym497 := z.EncBinary()
				_ = yym497
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberMisscheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym498 := z.EncBinary()
				_ = yym498
				if false {
				} else {
					r.EncodeInt(int64(x.NumberMisscheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym500 := z.EncBinary()
				_ = yym500
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("desiredNumberScheduled"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym501 := z.EncBinary()
				_ = yym501
				if false {
				} else {
					r.EncodeInt(int64(x.DesiredNumberScheduled))
				}
			}
			if yyr492 || yy2arr492 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym503 := z.EncBinary()
				_ = yym503
				if false {
				} else {
					r.EncodeInt(int64(x.NumberReady))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("numberReady"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym504 := z.EncBinary()
				_ = yym504
				if false {
				} else {
					r.EncodeInt(int64(x.NumberReady))
				}
			}
			if yyr492 || yy2arr492 {
				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
	yym505 := z.DecBinary()
	_ = yym505
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct506 := r.ContainerType()
		if yyct506 == codecSelferValueTypeMap1234 {
			yyl506 := r.ReadMapStart()
			if yyl506 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl506, d)
			}
		} else if yyct506 == codecSelferValueTypeArray1234 {
			yyl506 := r.ReadArrayStart()
			if yyl506 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl506, 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 yys507Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys507Slc
	var yyhl507 bool = l >= 0
	for yyj507 := 0; ; yyj507++ {
		if yyhl507 {
			if yyj507 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys507Slc = r.DecodeBytes(yys507Slc, true, true)
		yys507 := string(yys507Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys507 {
		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, yys507)
		} // end switch yys507
	} // end for yyj507
	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 yyj512 int
	var yyb512 bool
	var yyhl512 bool = l >= 0
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.CurrentNumberScheduled = 0
	} else {
		x.CurrentNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberMisscheduled = 0
	} else {
		x.NumberMisscheduled = int32(r.DecodeInt(32))
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DesiredNumberScheduled = 0
	} else {
		x.DesiredNumberScheduled = int32(r.DecodeInt(32))
	}
	yyj512++
	if yyhl512 {
		yyb512 = yyj512 > l
	} else {
		yyb512 = r.CheckBreak()
	}
	if yyb512 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.NumberReady = 0
	} else {
		x.NumberReady = int32(r.DecodeInt(32))
	}
	for {
		yyj512++
		if yyhl512 {
			yyb512 = yyj512 > l
		} else {
			yyb512 = r.CheckBreak()
		}
		if yyb512 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj512-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 {
		yym517 := z.EncBinary()
		_ = yym517
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep518 := !z.EncBinary()
			yy2arr518 := z.EncBasicHandle().StructToArray
			var yyq518 [5]bool
			_, _, _ = yysep518, yyq518, yy2arr518
			const yyr518 bool = false
			yyq518[0] = x.Kind != ""
			yyq518[1] = x.APIVersion != ""
			yyq518[2] = true
			yyq518[3] = true
			yyq518[4] = true
			var yynn518 int
			if yyr518 || yy2arr518 {
				r.EncodeArrayStart(5)
			} else {
				yynn518 = 0
				for _, b := range yyq518 {
					if b {
						yynn518++
					}
				}
				r.EncodeMapStart(yynn518)
				yynn518 = 0
			}
			if yyr518 || yy2arr518 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq518[0] {
					yym520 := z.EncBinary()
					_ = yym520
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq518[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym521 := z.EncBinary()
					_ = yym521
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr518 || yy2arr518 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq518[1] {
					yym523 := z.EncBinary()
					_ = yym523
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq518[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym524 := z.EncBinary()
					_ = yym524
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr518 || yy2arr518 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq518[2] {
					yy526 := &x.ObjectMeta
					yy526.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq518[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy527 := &x.ObjectMeta
					yy527.CodecEncodeSelf(e)
				}
			}
			if yyr518 || yy2arr518 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq518[3] {
					yy529 := &x.Spec
					yy529.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq518[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy530 := &x.Spec
					yy530.CodecEncodeSelf(e)
				}
			}
			if yyr518 || yy2arr518 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq518[4] {
					yy532 := &x.Status
					yy532.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq518[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy533 := &x.Status
					yy533.CodecEncodeSelf(e)
				}
			}
			if yyr518 || yy2arr518 {
				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
	yym534 := z.DecBinary()
	_ = yym534
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct535 := r.ContainerType()
		if yyct535 == codecSelferValueTypeMap1234 {
			yyl535 := r.ReadMapStart()
			if yyl535 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl535, d)
			}
		} else if yyct535 == codecSelferValueTypeArray1234 {
			yyl535 := r.ReadArrayStart()
			if yyl535 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl535, 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 yys536Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys536Slc
	var yyhl536 bool = l >= 0
	for yyj536 := 0; ; yyj536++ {
		if yyhl536 {
			if yyj536 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys536Slc = r.DecodeBytes(yys536Slc, true, true)
		yys536 := string(yys536Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys536 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv539 := &x.ObjectMeta
				yyv539.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = DaemonSetSpec{}
			} else {
				yyv540 := &x.Spec
				yyv540.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = DaemonSetStatus{}
			} else {
				yyv541 := &x.Status
				yyv541.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys536)
		} // end switch yys536
	} // end for yyj536
	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 yyj542 int
	var yyb542 bool
	var yyhl542 bool = l >= 0
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv545 := &x.ObjectMeta
		yyv545.CodecDecodeSelf(d)
	}
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = DaemonSetSpec{}
	} else {
		yyv546 := &x.Spec
		yyv546.CodecDecodeSelf(d)
	}
	yyj542++
	if yyhl542 {
		yyb542 = yyj542 > l
	} else {
		yyb542 = r.CheckBreak()
	}
	if yyb542 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = DaemonSetStatus{}
	} else {
		yyv547 := &x.Status
		yyv547.CodecDecodeSelf(d)
	}
	for {
		yyj542++
		if yyhl542 {
			yyb542 = yyj542 > l
		} else {
			yyb542 = r.CheckBreak()
		}
		if yyb542 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj542-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 {
		yym548 := z.EncBinary()
		_ = yym548
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep549 := !z.EncBinary()
			yy2arr549 := z.EncBasicHandle().StructToArray
			var yyq549 [4]bool
			_, _, _ = yysep549, yyq549, yy2arr549
			const yyr549 bool = false
			yyq549[0] = x.Kind != ""
			yyq549[1] = x.APIVersion != ""
			yyq549[2] = true
			var yynn549 int
			if yyr549 || yy2arr549 {
				r.EncodeArrayStart(4)
			} else {
				yynn549 = 1
				for _, b := range yyq549 {
					if b {
						yynn549++
					}
				}
				r.EncodeMapStart(yynn549)
				yynn549 = 0
			}
			if yyr549 || yy2arr549 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq549[0] {
					yym551 := z.EncBinary()
					_ = yym551
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq549[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym552 := z.EncBinary()
					_ = yym552
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr549 || yy2arr549 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq549[1] {
					yym554 := z.EncBinary()
					_ = yym554
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq549[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym555 := z.EncBinary()
					_ = yym555
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr549 || yy2arr549 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq549[2] {
					yy557 := &x.ListMeta
					yym558 := z.EncBinary()
					_ = yym558
					if false {
					} else if z.HasExtensions() && z.EncExt(yy557) {
					} else {
						z.EncFallback(yy557)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq549[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy559 := &x.ListMeta
					yym560 := z.EncBinary()
					_ = yym560
					if false {
					} else if z.HasExtensions() && z.EncExt(yy559) {
					} else {
						z.EncFallback(yy559)
					}
				}
			}
			if yyr549 || yy2arr549 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym562 := z.EncBinary()
					_ = yym562
					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 {
					yym563 := z.EncBinary()
					_ = yym563
					if false {
					} else {
						h.encSliceDaemonSet(([]DaemonSet)(x.Items), e)
					}
				}
			}
			if yyr549 || yy2arr549 {
				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
	yym564 := z.DecBinary()
	_ = yym564
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct565 := r.ContainerType()
		if yyct565 == codecSelferValueTypeMap1234 {
			yyl565 := r.ReadMapStart()
			if yyl565 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl565, d)
			}
		} else if yyct565 == codecSelferValueTypeArray1234 {
			yyl565 := r.ReadArrayStart()
			if yyl565 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl565, 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 yys566Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys566Slc
	var yyhl566 bool = l >= 0
	for yyj566 := 0; ; yyj566++ {
		if yyhl566 {
			if yyj566 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys566Slc = r.DecodeBytes(yys566Slc, true, true)
		yys566 := string(yys566Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys566 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv569 := &x.ListMeta
				yym570 := z.DecBinary()
				_ = yym570
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv569) {
				} else {
					z.DecFallback(yyv569, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv571 := &x.Items
				yym572 := z.DecBinary()
				_ = yym572
				if false {
				} else {
					h.decSliceDaemonSet((*[]DaemonSet)(yyv571), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys566)
		} // end switch yys566
	} // end for yyj566
	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 yyj573 int
	var yyb573 bool
	var yyhl573 bool = l >= 0
	yyj573++
	if yyhl573 {
		yyb573 = yyj573 > l
	} else {
		yyb573 = r.CheckBreak()
	}
	if yyb573 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj573++
	if yyhl573 {
		yyb573 = yyj573 > l
	} else {
		yyb573 = r.CheckBreak()
	}
	if yyb573 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj573++
	if yyhl573 {
		yyb573 = yyj573 > l
	} else {
		yyb573 = r.CheckBreak()
	}
	if yyb573 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv576 := &x.ListMeta
		yym577 := z.DecBinary()
		_ = yym577
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv576) {
		} else {
			z.DecFallback(yyv576, false)
		}
	}
	yyj573++
	if yyhl573 {
		yyb573 = yyj573 > l
	} else {
		yyb573 = r.CheckBreak()
	}
	if yyb573 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv578 := &x.Items
		yym579 := z.DecBinary()
		_ = yym579
		if false {
		} else {
			h.decSliceDaemonSet((*[]DaemonSet)(yyv578), d)
		}
	}
	for {
		yyj573++
		if yyhl573 {
			yyb573 = yyj573 > l
		} else {
			yyb573 = r.CheckBreak()
		}
		if yyb573 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj573-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 {
		yym580 := z.EncBinary()
		_ = yym580
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep581 := !z.EncBinary()
			yy2arr581 := z.EncBasicHandle().StructToArray
			var yyq581 [4]bool
			_, _, _ = yysep581, yyq581, yy2arr581
			const yyr581 bool = false
			yyq581[0] = x.Kind != ""
			yyq581[1] = x.APIVersion != ""
			yyq581[2] = true
			var yynn581 int
			if yyr581 || yy2arr581 {
				r.EncodeArrayStart(4)
			} else {
				yynn581 = 1
				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.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq581[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym584 := z.EncBinary()
					_ = yym584
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[1] {
					yym586 := z.EncBinary()
					_ = yym586
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq581[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym587 := z.EncBinary()
					_ = yym587
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq581[2] {
					yy589 := &x.ListMeta
					yym590 := z.EncBinary()
					_ = yym590
					if false {
					} else if z.HasExtensions() && z.EncExt(yy589) {
					} else {
						z.EncFallback(yy589)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq581[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy591 := &x.ListMeta
					yym592 := z.EncBinary()
					_ = yym592
					if false {
					} else if z.HasExtensions() && z.EncExt(yy591) {
					} else {
						z.EncFallback(yy591)
					}
				}
			}
			if yyr581 || yy2arr581 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym594 := z.EncBinary()
					_ = yym594
					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 {
					yym595 := z.EncBinary()
					_ = yym595
					if false {
					} else {
						h.encSliceThirdPartyResourceData(([]ThirdPartyResourceData)(x.Items), e)
					}
				}
			}
			if yyr581 || yy2arr581 {
				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
	yym596 := z.DecBinary()
	_ = yym596
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct597 := r.ContainerType()
		if yyct597 == codecSelferValueTypeMap1234 {
			yyl597 := r.ReadMapStart()
			if yyl597 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl597, d)
			}
		} else if yyct597 == codecSelferValueTypeArray1234 {
			yyl597 := r.ReadArrayStart()
			if yyl597 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl597, 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 yys598Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys598Slc
	var yyhl598 bool = l >= 0
	for yyj598 := 0; ; yyj598++ {
		if yyhl598 {
			if yyj598 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys598Slc = r.DecodeBytes(yys598Slc, true, true)
		yys598 := string(yys598Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys598 {
		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 {
				yyv601 := &x.ListMeta
				yym602 := z.DecBinary()
				_ = yym602
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv601) {
				} else {
					z.DecFallback(yyv601, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv603 := &x.Items
				yym604 := z.DecBinary()
				_ = yym604
				if false {
				} else {
					h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv603), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys598)
		} // end switch yys598
	} // end for yyj598
	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 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.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	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.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	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.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv608 := &x.ListMeta
		yym609 := z.DecBinary()
		_ = yym609
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv608) {
		} else {
			z.DecFallback(yyv608, false)
		}
	}
	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.Items = nil
	} else {
		yyv610 := &x.Items
		yym611 := z.DecBinary()
		_ = yym611
		if false {
		} else {
			h.decSliceThirdPartyResourceData((*[]ThirdPartyResourceData)(yyv610), d)
		}
	}
	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 *Ingress) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym612 := z.EncBinary()
		_ = yym612
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep613 := !z.EncBinary()
			yy2arr613 := z.EncBasicHandle().StructToArray
			var yyq613 [5]bool
			_, _, _ = yysep613, yyq613, yy2arr613
			const yyr613 bool = false
			yyq613[0] = x.Kind != ""
			yyq613[1] = x.APIVersion != ""
			yyq613[2] = true
			yyq613[3] = true
			yyq613[4] = true
			var yynn613 int
			if yyr613 || yy2arr613 {
				r.EncodeArrayStart(5)
			} else {
				yynn613 = 0
				for _, b := range yyq613 {
					if b {
						yynn613++
					}
				}
				r.EncodeMapStart(yynn613)
				yynn613 = 0
			}
			if yyr613 || yy2arr613 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq613[0] {
					yym615 := z.EncBinary()
					_ = yym615
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq613[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym616 := z.EncBinary()
					_ = yym616
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr613 || yy2arr613 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq613[1] {
					yym618 := z.EncBinary()
					_ = yym618
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq613[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym619 := z.EncBinary()
					_ = yym619
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr613 || yy2arr613 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq613[2] {
					yy621 := &x.ObjectMeta
					yy621.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq613[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy622 := &x.ObjectMeta
					yy622.CodecEncodeSelf(e)
				}
			}
			if yyr613 || yy2arr613 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq613[3] {
					yy624 := &x.Spec
					yy624.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq613[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy625 := &x.Spec
					yy625.CodecEncodeSelf(e)
				}
			}
			if yyr613 || yy2arr613 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq613[4] {
					yy627 := &x.Status
					yy627.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq613[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy628 := &x.Status
					yy628.CodecEncodeSelf(e)
				}
			}
			if yyr613 || yy2arr613 {
				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
	yym629 := z.DecBinary()
	_ = yym629
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct630 := r.ContainerType()
		if yyct630 == codecSelferValueTypeMap1234 {
			yyl630 := r.ReadMapStart()
			if yyl630 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl630, d)
			}
		} else if yyct630 == codecSelferValueTypeArray1234 {
			yyl630 := r.ReadArrayStart()
			if yyl630 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl630, 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 yys631Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys631Slc
	var yyhl631 bool = l >= 0
	for yyj631 := 0; ; yyj631++ {
		if yyhl631 {
			if yyj631 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys631Slc = r.DecodeBytes(yys631Slc, true, true)
		yys631 := string(yys631Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys631 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv634 := &x.ObjectMeta
				yyv634.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = IngressSpec{}
			} else {
				yyv635 := &x.Spec
				yyv635.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = IngressStatus{}
			} else {
				yyv636 := &x.Status
				yyv636.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys631)
		} // end switch yys631
	} // end for yyj631
	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 yyj637 int
	var yyb637 bool
	var yyhl637 bool = l >= 0
	yyj637++
	if yyhl637 {
		yyb637 = yyj637 > l
	} else {
		yyb637 = r.CheckBreak()
	}
	if yyb637 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj637++
	if yyhl637 {
		yyb637 = yyj637 > l
	} else {
		yyb637 = r.CheckBreak()
	}
	if yyb637 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj637++
	if yyhl637 {
		yyb637 = yyj637 > l
	} else {
		yyb637 = r.CheckBreak()
	}
	if yyb637 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv640 := &x.ObjectMeta
		yyv640.CodecDecodeSelf(d)
	}
	yyj637++
	if yyhl637 {
		yyb637 = yyj637 > l
	} else {
		yyb637 = r.CheckBreak()
	}
	if yyb637 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = IngressSpec{}
	} else {
		yyv641 := &x.Spec
		yyv641.CodecDecodeSelf(d)
	}
	yyj637++
	if yyhl637 {
		yyb637 = yyj637 > l
	} else {
		yyb637 = r.CheckBreak()
	}
	if yyb637 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = IngressStatus{}
	} else {
		yyv642 := &x.Status
		yyv642.CodecDecodeSelf(d)
	}
	for {
		yyj637++
		if yyhl637 {
			yyb637 = yyj637 > l
		} else {
			yyb637 = r.CheckBreak()
		}
		if yyb637 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj637-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 {
		yym643 := z.EncBinary()
		_ = yym643
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep644 := !z.EncBinary()
			yy2arr644 := z.EncBasicHandle().StructToArray
			var yyq644 [4]bool
			_, _, _ = yysep644, yyq644, yy2arr644
			const yyr644 bool = false
			yyq644[0] = x.Kind != ""
			yyq644[1] = x.APIVersion != ""
			yyq644[2] = true
			var yynn644 int
			if yyr644 || yy2arr644 {
				r.EncodeArrayStart(4)
			} 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] {
					yym646 := z.EncBinary()
					_ = yym646
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq644[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym647 := z.EncBinary()
					_ = yym647
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq644[1] {
					yym649 := z.EncBinary()
					_ = yym649
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq644[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym650 := z.EncBinary()
					_ = yym650
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq644[2] {
					yy652 := &x.ListMeta
					yym653 := z.EncBinary()
					_ = yym653
					if false {
					} else if z.HasExtensions() && z.EncExt(yy652) {
					} else {
						z.EncFallback(yy652)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq644[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy654 := &x.ListMeta
					yym655 := z.EncBinary()
					_ = yym655
					if false {
					} else if z.HasExtensions() && z.EncExt(yy654) {
					} else {
						z.EncFallback(yy654)
					}
				}
			}
			if yyr644 || yy2arr644 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym657 := z.EncBinary()
					_ = yym657
					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 {
					yym658 := z.EncBinary()
					_ = yym658
					if false {
					} else {
						h.encSliceIngress(([]Ingress)(x.Items), e)
					}
				}
			}
			if yyr644 || yy2arr644 {
				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
	yym659 := z.DecBinary()
	_ = yym659
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct660 := r.ContainerType()
		if yyct660 == codecSelferValueTypeMap1234 {
			yyl660 := r.ReadMapStart()
			if yyl660 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl660, d)
			}
		} else if yyct660 == codecSelferValueTypeArray1234 {
			yyl660 := r.ReadArrayStart()
			if yyl660 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl660, 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 yys661Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys661Slc
	var yyhl661 bool = l >= 0
	for yyj661 := 0; ; yyj661++ {
		if yyhl661 {
			if yyj661 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys661Slc = r.DecodeBytes(yys661Slc, true, true)
		yys661 := string(yys661Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys661 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ListMeta = pkg1_unversioned.ListMeta{}
			} else {
				yyv664 := &x.ListMeta
				yym665 := z.DecBinary()
				_ = yym665
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv664) {
				} else {
					z.DecFallback(yyv664, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv666 := &x.Items
				yym667 := z.DecBinary()
				_ = yym667
				if false {
				} else {
					h.decSliceIngress((*[]Ingress)(yyv666), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys661)
		} // end switch yys661
	} // end for yyj661
	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 yyj668 int
	var yyb668 bool
	var yyhl668 bool = l >= 0
	yyj668++
	if yyhl668 {
		yyb668 = yyj668 > l
	} else {
		yyb668 = r.CheckBreak()
	}
	if yyb668 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj668++
	if yyhl668 {
		yyb668 = yyj668 > l
	} else {
		yyb668 = r.CheckBreak()
	}
	if yyb668 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj668++
	if yyhl668 {
		yyb668 = yyj668 > l
	} else {
		yyb668 = r.CheckBreak()
	}
	if yyb668 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv671 := &x.ListMeta
		yym672 := z.DecBinary()
		_ = yym672
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv671) {
		} else {
			z.DecFallback(yyv671, false)
		}
	}
	yyj668++
	if yyhl668 {
		yyb668 = yyj668 > l
	} else {
		yyb668 = r.CheckBreak()
	}
	if yyb668 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv673 := &x.Items
		yym674 := z.DecBinary()
		_ = yym674
		if false {
		} else {
			h.decSliceIngress((*[]Ingress)(yyv673), d)
		}
	}
	for {
		yyj668++
		if yyhl668 {
			yyb668 = yyj668 > l
		} else {
			yyb668 = r.CheckBreak()
		}
		if yyb668 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj668-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 {
		yym675 := z.EncBinary()
		_ = yym675
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep676 := !z.EncBinary()
			yy2arr676 := z.EncBasicHandle().StructToArray
			var yyq676 [3]bool
			_, _, _ = yysep676, yyq676, yy2arr676
			const yyr676 bool = false
			yyq676[0] = x.Backend != nil
			yyq676[1] = len(x.TLS) != 0
			yyq676[2] = len(x.Rules) != 0
			var yynn676 int
			if yyr676 || yy2arr676 {
				r.EncodeArrayStart(3)
			} else {
				yynn676 = 0
				for _, b := range yyq676 {
					if b {
						yynn676++
					}
				}
				r.EncodeMapStart(yynn676)
				yynn676 = 0
			}
			if yyr676 || yy2arr676 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq676[0] {
					if x.Backend == nil {
						r.EncodeNil()
					} else {
						x.Backend.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq676[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 yyr676 || yy2arr676 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq676[1] {
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym679 := z.EncBinary()
						_ = yym679
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq676[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("tls"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.TLS == nil {
						r.EncodeNil()
					} else {
						yym680 := z.EncBinary()
						_ = yym680
						if false {
						} else {
							h.encSliceIngressTLS(([]IngressTLS)(x.TLS), e)
						}
					}
				}
			}
			if yyr676 || yy2arr676 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq676[2] {
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym682 := z.EncBinary()
						_ = yym682
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq676[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rules"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Rules == nil {
						r.EncodeNil()
					} else {
						yym683 := z.EncBinary()
						_ = yym683
						if false {
						} else {
							h.encSliceIngressRule(([]IngressRule)(x.Rules), e)
						}
					}
				}
			}
			if yyr676 || yy2arr676 {
				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
	yym684 := z.DecBinary()
	_ = yym684
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct685 := r.ContainerType()
		if yyct685 == codecSelferValueTypeMap1234 {
			yyl685 := r.ReadMapStart()
			if yyl685 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl685, d)
			}
		} else if yyct685 == codecSelferValueTypeArray1234 {
			yyl685 := r.ReadArrayStart()
			if yyl685 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl685, 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 yys686Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys686Slc
	var yyhl686 bool = l >= 0
	for yyj686 := 0; ; yyj686++ {
		if yyhl686 {
			if yyj686 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys686Slc = r.DecodeBytes(yys686Slc, true, true)
		yys686 := string(yys686Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys686 {
		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 {
				yyv688 := &x.TLS
				yym689 := z.DecBinary()
				_ = yym689
				if false {
				} else {
					h.decSliceIngressTLS((*[]IngressTLS)(yyv688), d)
				}
			}
		case "rules":
			if r.TryDecodeAsNil() {
				x.Rules = nil
			} else {
				yyv690 := &x.Rules
				yym691 := z.DecBinary()
				_ = yym691
				if false {
				} else {
					h.decSliceIngressRule((*[]IngressRule)(yyv690), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys686)
		} // end switch yys686
	} // end for yyj686
	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 yyj692 int
	var yyb692 bool
	var yyhl692 bool = l >= 0
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		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)
	}
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.TLS = nil
	} else {
		yyv694 := &x.TLS
		yym695 := z.DecBinary()
		_ = yym695
		if false {
		} else {
			h.decSliceIngressTLS((*[]IngressTLS)(yyv694), d)
		}
	}
	yyj692++
	if yyhl692 {
		yyb692 = yyj692 > l
	} else {
		yyb692 = r.CheckBreak()
	}
	if yyb692 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rules = nil
	} else {
		yyv696 := &x.Rules
		yym697 := z.DecBinary()
		_ = yym697
		if false {
		} else {
			h.decSliceIngressRule((*[]IngressRule)(yyv696), d)
		}
	}
	for {
		yyj692++
		if yyhl692 {
			yyb692 = yyj692 > l
		} else {
			yyb692 = r.CheckBreak()
		}
		if yyb692 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj692-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 {
		yym698 := z.EncBinary()
		_ = yym698
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep699 := !z.EncBinary()
			yy2arr699 := z.EncBasicHandle().StructToArray
			var yyq699 [2]bool
			_, _, _ = yysep699, yyq699, yy2arr699
			const yyr699 bool = false
			yyq699[0] = len(x.Hosts) != 0
			yyq699[1] = x.SecretName != ""
			var yynn699 int
			if yyr699 || yy2arr699 {
				r.EncodeArrayStart(2)
			} else {
				yynn699 = 0
				for _, b := range yyq699 {
					if b {
						yynn699++
					}
				}
				r.EncodeMapStart(yynn699)
				yynn699 = 0
			}
			if yyr699 || yy2arr699 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq699[0] {
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym701 := z.EncBinary()
						_ = yym701
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq699[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hosts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Hosts == nil {
						r.EncodeNil()
					} else {
						yym702 := z.EncBinary()
						_ = yym702
						if false {
						} else {
							z.F.EncSliceStringV(x.Hosts, false, e)
						}
					}
				}
			}
			if yyr699 || yy2arr699 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq699[1] {
					yym704 := z.EncBinary()
					_ = yym704
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq699[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("secretName"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym705 := z.EncBinary()
					_ = yym705
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.SecretName))
					}
				}
			}
			if yyr699 || yy2arr699 {
				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
	yym706 := z.DecBinary()
	_ = yym706
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct707 := r.ContainerType()
		if yyct707 == codecSelferValueTypeMap1234 {
			yyl707 := r.ReadMapStart()
			if yyl707 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl707, d)
			}
		} else if yyct707 == codecSelferValueTypeArray1234 {
			yyl707 := r.ReadArrayStart()
			if yyl707 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl707, 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 yys708Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys708Slc
	var yyhl708 bool = l >= 0
	for yyj708 := 0; ; yyj708++ {
		if yyhl708 {
			if yyj708 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys708Slc = r.DecodeBytes(yys708Slc, true, true)
		yys708 := string(yys708Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys708 {
		case "hosts":
			if r.TryDecodeAsNil() {
				x.Hosts = nil
			} else {
				yyv709 := &x.Hosts
				yym710 := z.DecBinary()
				_ = yym710
				if false {
				} else {
					z.F.DecSliceStringX(yyv709, false, d)
				}
			}
		case "secretName":
			if r.TryDecodeAsNil() {
				x.SecretName = ""
			} else {
				x.SecretName = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys708)
		} // end switch yys708
	} // end for yyj708
	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 yyj712 int
	var yyb712 bool
	var yyhl712 bool = l >= 0
	yyj712++
	if yyhl712 {
		yyb712 = yyj712 > l
	} else {
		yyb712 = r.CheckBreak()
	}
	if yyb712 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Hosts = nil
	} else {
		yyv713 := &x.Hosts
		yym714 := z.DecBinary()
		_ = yym714
		if false {
		} else {
			z.F.DecSliceStringX(yyv713, false, d)
		}
	}
	yyj712++
	if yyhl712 {
		yyb712 = yyj712 > l
	} else {
		yyb712 = r.CheckBreak()
	}
	if yyb712 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SecretName = ""
	} else {
		x.SecretName = string(r.DecodeString())
	}
	for {
		yyj712++
		if yyhl712 {
			yyb712 = yyj712 > l
		} else {
			yyb712 = r.CheckBreak()
		}
		if yyb712 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj712-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 {
		yym716 := z.EncBinary()
		_ = yym716
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep717 := !z.EncBinary()
			yy2arr717 := z.EncBasicHandle().StructToArray
			var yyq717 [1]bool
			_, _, _ = yysep717, yyq717, yy2arr717
			const yyr717 bool = false
			yyq717[0] = true
			var yynn717 int
			if yyr717 || yy2arr717 {
				r.EncodeArrayStart(1)
			} else {
				yynn717 = 0
				for _, b := range yyq717 {
					if b {
						yynn717++
					}
				}
				r.EncodeMapStart(yynn717)
				yynn717 = 0
			}
			if yyr717 || yy2arr717 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq717[0] {
					yy719 := &x.LoadBalancer
					yy719.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq717[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy720 := &x.LoadBalancer
					yy720.CodecEncodeSelf(e)
				}
			}
			if yyr717 || yy2arr717 {
				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
	yym721 := z.DecBinary()
	_ = yym721
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct722 := r.ContainerType()
		if yyct722 == codecSelferValueTypeMap1234 {
			yyl722 := r.ReadMapStart()
			if yyl722 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl722, d)
			}
		} else if yyct722 == codecSelferValueTypeArray1234 {
			yyl722 := r.ReadArrayStart()
			if yyl722 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl722, 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 yys723Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys723Slc
	var yyhl723 bool = l >= 0
	for yyj723 := 0; ; yyj723++ {
		if yyhl723 {
			if yyj723 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys723Slc = r.DecodeBytes(yys723Slc, true, true)
		yys723 := string(yys723Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys723 {
		case "loadBalancer":
			if r.TryDecodeAsNil() {
				x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
			} else {
				yyv724 := &x.LoadBalancer
				yyv724.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys723)
		} // end switch yys723
	} // end for yyj723
	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 yyj725 int
	var yyb725 bool
	var yyhl725 bool = l >= 0
	yyj725++
	if yyhl725 {
		yyb725 = yyj725 > l
	} else {
		yyb725 = r.CheckBreak()
	}
	if yyb725 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LoadBalancer = pkg2_api.LoadBalancerStatus{}
	} else {
		yyv726 := &x.LoadBalancer
		yyv726.CodecDecodeSelf(d)
	}
	for {
		yyj725++
		if yyhl725 {
			yyb725 = yyj725 > l
		} else {
			yyb725 = r.CheckBreak()
		}
		if yyb725 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj725-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 {
		yym727 := z.EncBinary()
		_ = yym727
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep728 := !z.EncBinary()
			yy2arr728 := z.EncBasicHandle().StructToArray
			var yyq728 [2]bool
			_, _, _ = yysep728, yyq728, yy2arr728
			const yyr728 bool = false
			yyq728[0] = x.Host != ""
			yyq728[1] = x.IngressRuleValue.HTTP != nil && x.HTTP != nil
			var yynn728 int
			if yyr728 || yy2arr728 {
				r.EncodeArrayStart(2)
			} else {
				yynn728 = 0
				for _, b := range yyq728 {
					if b {
						yynn728++
					}
				}
				r.EncodeMapStart(yynn728)
				yynn728 = 0
			}
			if yyr728 || yy2arr728 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq728[0] {
					yym730 := z.EncBinary()
					_ = yym730
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq728[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("host"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym731 := z.EncBinary()
					_ = yym731
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Host))
					}
				}
			}
			var yyn732 bool
			if x.IngressRuleValue.HTTP == nil {
				yyn732 = true
				goto LABEL732
			}
		LABEL732:
			if yyr728 || yy2arr728 {
				if yyn732 {
					r.EncodeNil()
				} else {
					z.EncSendContainerState(codecSelfer_containerArrayElem1234)
					if yyq728[1] {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					} else {
						r.EncodeNil()
					}
				}
			} else {
				if yyq728[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("http"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if yyn732 {
						r.EncodeNil()
					} else {
						if x.HTTP == nil {
							r.EncodeNil()
						} else {
							x.HTTP.CodecEncodeSelf(e)
						}
					}
				}
			}
			if yyr728 || yy2arr728 {
				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
	yym733 := z.DecBinary()
	_ = yym733
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct734 := r.ContainerType()
		if yyct734 == codecSelferValueTypeMap1234 {
			yyl734 := r.ReadMapStart()
			if yyl734 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl734, d)
			}
		} else if yyct734 == codecSelferValueTypeArray1234 {
			yyl734 := r.ReadArrayStart()
			if yyl734 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl734, 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 yys735Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys735Slc
	var yyhl735 bool = l >= 0
	for yyj735 := 0; ; yyj735++ {
		if yyhl735 {
			if yyj735 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys735Slc = r.DecodeBytes(yys735Slc, true, true)
		yys735 := string(yys735Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys735 {
		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, yys735)
		} // end switch yys735
	} // end for yyj735
	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 yyj738 int
	var yyb738 bool
	var yyhl738 bool = l >= 0
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		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)
	}
	yyj738++
	if yyhl738 {
		yyb738 = yyj738 > l
	} else {
		yyb738 = r.CheckBreak()
	}
	if yyb738 {
		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 {
		yyj738++
		if yyhl738 {
			yyb738 = yyj738 > l
		} else {
			yyb738 = r.CheckBreak()
		}
		if yyb738 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj738-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 {
		yym741 := z.EncBinary()
		_ = yym741
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep742 := !z.EncBinary()
			yy2arr742 := z.EncBasicHandle().StructToArray
			var yyq742 [1]bool
			_, _, _ = yysep742, yyq742, yy2arr742
			const yyr742 bool = false
			yyq742[0] = x.HTTP != nil
			var yynn742 int
			if yyr742 || yy2arr742 {
				r.EncodeArrayStart(1)
			} else {
				yynn742 = 0
				for _, b := range yyq742 {
					if b {
						yynn742++
					}
				}
				r.EncodeMapStart(yynn742)
				yynn742 = 0
			}
			if yyr742 || yy2arr742 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq742[0] {
					if x.HTTP == nil {
						r.EncodeNil()
					} else {
						x.HTTP.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq742[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 yyr742 || yy2arr742 {
				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
	yym744 := z.DecBinary()
	_ = yym744
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct745 := r.ContainerType()
		if yyct745 == codecSelferValueTypeMap1234 {
			yyl745 := r.ReadMapStart()
			if yyl745 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl745, d)
			}
		} else if yyct745 == codecSelferValueTypeArray1234 {
			yyl745 := r.ReadArrayStart()
			if yyl745 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl745, 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 yys746Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys746Slc
	var yyhl746 bool = l >= 0
	for yyj746 := 0; ; yyj746++ {
		if yyhl746 {
			if yyj746 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys746Slc = r.DecodeBytes(yys746Slc, true, true)
		yys746 := string(yys746Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys746 {
		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, yys746)
		} // end switch yys746
	} // end for yyj746
	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 yyj748 int
	var yyb748 bool
	var yyhl748 bool = l >= 0
	yyj748++
	if yyhl748 {
		yyb748 = yyj748 > l
	} else {
		yyb748 = r.CheckBreak()
	}
	if yyb748 {
		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 {
		yyj748++
		if yyhl748 {
			yyb748 = yyj748 > l
		} else {
			yyb748 = r.CheckBreak()
		}
		if yyb748 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj748-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 {
		yym750 := z.EncBinary()
		_ = yym750
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep751 := !z.EncBinary()
			yy2arr751 := z.EncBasicHandle().StructToArray
			var yyq751 [1]bool
			_, _, _ = yysep751, yyq751, yy2arr751
			const yyr751 bool = false
			var yynn751 int
			if yyr751 || yy2arr751 {
				r.EncodeArrayStart(1)
			} else {
				yynn751 = 1
				for _, b := range yyq751 {
					if b {
						yynn751++
					}
				}
				r.EncodeMapStart(yynn751)
				yynn751 = 0
			}
			if yyr751 || yy2arr751 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Paths == nil {
					r.EncodeNil()
				} else {
					yym753 := z.EncBinary()
					_ = yym753
					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 {
					yym754 := z.EncBinary()
					_ = yym754
					if false {
					} else {
						h.encSliceHTTPIngressPath(([]HTTPIngressPath)(x.Paths), e)
					}
				}
			}
			if yyr751 || yy2arr751 {
				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
	yym755 := z.DecBinary()
	_ = yym755
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct756 := r.ContainerType()
		if yyct756 == codecSelferValueTypeMap1234 {
			yyl756 := r.ReadMapStart()
			if yyl756 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl756, d)
			}
		} else if yyct756 == codecSelferValueTypeArray1234 {
			yyl756 := r.ReadArrayStart()
			if yyl756 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl756, 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 yys757Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys757Slc
	var yyhl757 bool = l >= 0
	for yyj757 := 0; ; yyj757++ {
		if yyhl757 {
			if yyj757 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys757Slc = r.DecodeBytes(yys757Slc, true, true)
		yys757 := string(yys757Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys757 {
		case "paths":
			if r.TryDecodeAsNil() {
				x.Paths = nil
			} else {
				yyv758 := &x.Paths
				yym759 := z.DecBinary()
				_ = yym759
				if false {
				} else {
					h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv758), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys757)
		} // end switch yys757
	} // end for yyj757
	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 yyj760 int
	var yyb760 bool
	var yyhl760 bool = l >= 0
	yyj760++
	if yyhl760 {
		yyb760 = yyj760 > l
	} else {
		yyb760 = r.CheckBreak()
	}
	if yyb760 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Paths = nil
	} else {
		yyv761 := &x.Paths
		yym762 := z.DecBinary()
		_ = yym762
		if false {
		} else {
			h.decSliceHTTPIngressPath((*[]HTTPIngressPath)(yyv761), d)
		}
	}
	for {
		yyj760++
		if yyhl760 {
			yyb760 = yyj760 > l
		} else {
			yyb760 = r.CheckBreak()
		}
		if yyb760 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj760-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 {
		yym763 := z.EncBinary()
		_ = yym763
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep764 := !z.EncBinary()
			yy2arr764 := z.EncBasicHandle().StructToArray
			var yyq764 [2]bool
			_, _, _ = yysep764, yyq764, yy2arr764
			const yyr764 bool = false
			yyq764[0] = x.Path != ""
			var yynn764 int
			if yyr764 || yy2arr764 {
				r.EncodeArrayStart(2)
			} else {
				yynn764 = 1
				for _, b := range yyq764 {
					if b {
						yynn764++
					}
				}
				r.EncodeMapStart(yynn764)
				yynn764 = 0
			}
			if yyr764 || yy2arr764 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq764[0] {
					yym766 := z.EncBinary()
					_ = yym766
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq764[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym767 := z.EncBinary()
					_ = yym767
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr764 || yy2arr764 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy769 := &x.Backend
				yy769.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("backend"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy770 := &x.Backend
				yy770.CodecEncodeSelf(e)
			}
			if yyr764 || yy2arr764 {
				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
	yym771 := z.DecBinary()
	_ = yym771
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct772 := r.ContainerType()
		if yyct772 == codecSelferValueTypeMap1234 {
			yyl772 := r.ReadMapStart()
			if yyl772 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl772, d)
			}
		} else if yyct772 == codecSelferValueTypeArray1234 {
			yyl772 := r.ReadArrayStart()
			if yyl772 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl772, 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 yys773Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys773Slc
	var yyhl773 bool = l >= 0
	for yyj773 := 0; ; yyj773++ {
		if yyhl773 {
			if yyj773 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys773Slc = r.DecodeBytes(yys773Slc, true, true)
		yys773 := string(yys773Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys773 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "backend":
			if r.TryDecodeAsNil() {
				x.Backend = IngressBackend{}
			} else {
				yyv775 := &x.Backend
				yyv775.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys773)
		} // end switch yys773
	} // end for yyj773
	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 yyj776 int
	var yyb776 bool
	var yyhl776 bool = l >= 0
	yyj776++
	if yyhl776 {
		yyb776 = yyj776 > l
	} else {
		yyb776 = r.CheckBreak()
	}
	if yyb776 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj776++
	if yyhl776 {
		yyb776 = yyj776 > l
	} else {
		yyb776 = r.CheckBreak()
	}
	if yyb776 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Backend = IngressBackend{}
	} else {
		yyv778 := &x.Backend
		yyv778.CodecDecodeSelf(d)
	}
	for {
		yyj776++
		if yyhl776 {
			yyb776 = yyj776 > l
		} else {
			yyb776 = r.CheckBreak()
		}
		if yyb776 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj776-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 {
		yym779 := z.EncBinary()
		_ = yym779
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep780 := !z.EncBinary()
			yy2arr780 := z.EncBasicHandle().StructToArray
			var yyq780 [2]bool
			_, _, _ = yysep780, yyq780, yy2arr780
			const yyr780 bool = false
			var yynn780 int
			if yyr780 || yy2arr780 {
				r.EncodeArrayStart(2)
			} else {
				yynn780 = 2
				for _, b := range yyq780 {
					if b {
						yynn780++
					}
				}
				r.EncodeMapStart(yynn780)
				yynn780 = 0
			}
			if yyr780 || yy2arr780 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym782 := z.EncBinary()
				_ = yym782
				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)
				yym783 := z.EncBinary()
				_ = yym783
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.ServiceName))
				}
			}
			if yyr780 || yy2arr780 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy785 := &x.ServicePort
				yym786 := z.EncBinary()
				_ = yym786
				if false {
				} else if z.HasExtensions() && z.EncExt(yy785) {
				} else if !yym786 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy785)
				} else {
					z.EncFallback(yy785)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("servicePort"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy787 := &x.ServicePort
				yym788 := z.EncBinary()
				_ = yym788
				if false {
				} else if z.HasExtensions() && z.EncExt(yy787) {
				} else if !yym788 && z.IsJSONHandle() {
					z.EncJSONMarshal(yy787)
				} else {
					z.EncFallback(yy787)
				}
			}
			if yyr780 || yy2arr780 {
				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
	yym789 := z.DecBinary()
	_ = yym789
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct790 := r.ContainerType()
		if yyct790 == codecSelferValueTypeMap1234 {
			yyl790 := r.ReadMapStart()
			if yyl790 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl790, d)
			}
		} else if yyct790 == codecSelferValueTypeArray1234 {
			yyl790 := r.ReadArrayStart()
			if yyl790 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl790, 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 yys791Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys791Slc
	var yyhl791 bool = l >= 0
	for yyj791 := 0; ; yyj791++ {
		if yyhl791 {
			if yyj791 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys791Slc = r.DecodeBytes(yys791Slc, true, true)
		yys791 := string(yys791Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys791 {
		case "serviceName":
			if r.TryDecodeAsNil() {
				x.ServiceName = ""
			} else {
				x.ServiceName = string(r.DecodeString())
			}
		case "servicePort":
			if r.TryDecodeAsNil() {
				x.ServicePort = pkg5_intstr.IntOrString{}
			} else {
				yyv793 := &x.ServicePort
				yym794 := z.DecBinary()
				_ = yym794
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv793) {
				} else if !yym794 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv793)
				} else {
					z.DecFallback(yyv793, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys791)
		} // end switch yys791
	} // end for yyj791
	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 yyj795 int
	var yyb795 bool
	var yyhl795 bool = l >= 0
	yyj795++
	if yyhl795 {
		yyb795 = yyj795 > l
	} else {
		yyb795 = r.CheckBreak()
	}
	if yyb795 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServiceName = ""
	} else {
		x.ServiceName = string(r.DecodeString())
	}
	yyj795++
	if yyhl795 {
		yyb795 = yyj795 > l
	} else {
		yyb795 = r.CheckBreak()
	}
	if yyb795 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ServicePort = pkg5_intstr.IntOrString{}
	} else {
		yyv797 := &x.ServicePort
		yym798 := z.DecBinary()
		_ = yym798
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv797) {
		} else if !yym798 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv797)
		} else {
			z.DecFallback(yyv797, false)
		}
	}
	for {
		yyj795++
		if yyhl795 {
			yyb795 = yyj795 > l
		} else {
			yyb795 = r.CheckBreak()
		}
		if yyb795 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj795-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ReplicaSet) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym799 := z.EncBinary()
		_ = yym799
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep800 := !z.EncBinary()
			yy2arr800 := z.EncBasicHandle().StructToArray
			var yyq800 [5]bool
			_, _, _ = yysep800, yyq800, yy2arr800
			const yyr800 bool = false
			yyq800[0] = x.Kind != ""
			yyq800[1] = x.APIVersion != ""
			yyq800[2] = true
			yyq800[3] = true
			yyq800[4] = true
			var yynn800 int
			if yyr800 || yy2arr800 {
				r.EncodeArrayStart(5)
			} else {
				yynn800 = 0
				for _, b := range yyq800 {
					if b {
						yynn800++
					}
				}
				r.EncodeMapStart(yynn800)
				yynn800 = 0
			}
			if yyr800 || yy2arr800 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq800[0] {
					yym802 := z.EncBinary()
					_ = yym802
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq800[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym803 := z.EncBinary()
					_ = yym803
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr800 || yy2arr800 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq800[1] {
					yym805 := z.EncBinary()
					_ = yym805
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq800[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym806 := z.EncBinary()
					_ = yym806
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr800 || yy2arr800 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq800[2] {
					yy808 := &x.ObjectMeta
					yy808.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq800[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy809 := &x.ObjectMeta
					yy809.CodecEncodeSelf(e)
				}
			}
			if yyr800 || yy2arr800 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq800[3] {
					yy811 := &x.Spec
					yy811.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq800[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy812 := &x.Spec
					yy812.CodecEncodeSelf(e)
				}
			}
			if yyr800 || yy2arr800 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq800[4] {
					yy814 := &x.Status
					yy814.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq800[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy815 := &x.Status
					yy815.CodecEncodeSelf(e)
				}
			}
			if yyr800 || yy2arr800 {
				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
	yym816 := z.DecBinary()
	_ = yym816
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct817 := r.ContainerType()
		if yyct817 == codecSelferValueTypeMap1234 {
			yyl817 := r.ReadMapStart()
			if yyl817 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl817, d)
			}
		} else if yyct817 == codecSelferValueTypeArray1234 {
			yyl817 := r.ReadArrayStart()
			if yyl817 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl817, 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 yys818Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys818Slc
	var yyhl818 bool = l >= 0
	for yyj818 := 0; ; yyj818++ {
		if yyhl818 {
			if yyj818 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys818Slc = r.DecodeBytes(yys818Slc, true, true)
		yys818 := string(yys818Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys818 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv821 := &x.ObjectMeta
				yyv821.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = ReplicaSetSpec{}
			} else {
				yyv822 := &x.Spec
				yyv822.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ReplicaSetStatus{}
			} else {
				yyv823 := &x.Status
				yyv823.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys818)
		} // end switch yys818
	} // end for yyj818
	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 yyj824 int
	var yyb824 bool
	var yyhl824 bool = l >= 0
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv827 := &x.ObjectMeta
		yyv827.CodecDecodeSelf(d)
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = ReplicaSetSpec{}
	} else {
		yyv828 := &x.Spec
		yyv828.CodecDecodeSelf(d)
	}
	yyj824++
	if yyhl824 {
		yyb824 = yyj824 > l
	} else {
		yyb824 = r.CheckBreak()
	}
	if yyb824 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ReplicaSetStatus{}
	} else {
		yyv829 := &x.Status
		yyv829.CodecDecodeSelf(d)
	}
	for {
		yyj824++
		if yyhl824 {
			yyb824 = yyj824 > l
		} else {
			yyb824 = r.CheckBreak()
		}
		if yyb824 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj824-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 {
		yym830 := z.EncBinary()
		_ = yym830
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep831 := !z.EncBinary()
			yy2arr831 := z.EncBasicHandle().StructToArray
			var yyq831 [4]bool
			_, _, _ = yysep831, yyq831, yy2arr831
			const yyr831 bool = false
			yyq831[0] = x.Kind != ""
			yyq831[1] = x.APIVersion != ""
			yyq831[2] = true
			var yynn831 int
			if yyr831 || yy2arr831 {
				r.EncodeArrayStart(4)
			} else {
				yynn831 = 1
				for _, b := range yyq831 {
					if b {
						yynn831++
					}
				}
				r.EncodeMapStart(yynn831)
				yynn831 = 0
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[0] {
					yym833 := z.EncBinary()
					_ = yym833
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym834 := z.EncBinary()
					_ = yym834
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[1] {
					yym836 := z.EncBinary()
					_ = yym836
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq831[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym837 := z.EncBinary()
					_ = yym837
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq831[2] {
					yy839 := &x.ListMeta
					yym840 := z.EncBinary()
					_ = yym840
					if false {
					} else if z.HasExtensions() && z.EncExt(yy839) {
					} else {
						z.EncFallback(yy839)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq831[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy841 := &x.ListMeta
					yym842 := z.EncBinary()
					_ = yym842
					if false {
					} else if z.HasExtensions() && z.EncExt(yy841) {
					} else {
						z.EncFallback(yy841)
					}
				}
			}
			if yyr831 || yy2arr831 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym844 := z.EncBinary()
					_ = yym844
					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 {
					yym845 := z.EncBinary()
					_ = yym845
					if false {
					} else {
						h.encSliceReplicaSet(([]ReplicaSet)(x.Items), e)
					}
				}
			}
			if yyr831 || yy2arr831 {
				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
	yym846 := z.DecBinary()
	_ = yym846
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct847 := r.ContainerType()
		if yyct847 == codecSelferValueTypeMap1234 {
			yyl847 := r.ReadMapStart()
			if yyl847 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl847, d)
			}
		} else if yyct847 == codecSelferValueTypeArray1234 {
			yyl847 := r.ReadArrayStart()
			if yyl847 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl847, 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 yys848Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys848Slc
	var yyhl848 bool = l >= 0
	for yyj848 := 0; ; yyj848++ {
		if yyhl848 {
			if yyj848 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys848Slc = r.DecodeBytes(yys848Slc, true, true)
		yys848 := string(yys848Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys848 {
		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 {
				yyv851 := &x.ListMeta
				yym852 := z.DecBinary()
				_ = yym852
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv851) {
				} else {
					z.DecFallback(yyv851, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv853 := &x.Items
				yym854 := z.DecBinary()
				_ = yym854
				if false {
				} else {
					h.decSliceReplicaSet((*[]ReplicaSet)(yyv853), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys848)
		} // end switch yys848
	} // end for yyj848
	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 yyj855 int
	var yyb855 bool
	var yyhl855 bool = l >= 0
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv858 := &x.ListMeta
		yym859 := z.DecBinary()
		_ = yym859
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv858) {
		} else {
			z.DecFallback(yyv858, false)
		}
	}
	yyj855++
	if yyhl855 {
		yyb855 = yyj855 > l
	} else {
		yyb855 = r.CheckBreak()
	}
	if yyb855 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv860 := &x.Items
		yym861 := z.DecBinary()
		_ = yym861
		if false {
		} else {
			h.decSliceReplicaSet((*[]ReplicaSet)(yyv860), d)
		}
	}
	for {
		yyj855++
		if yyhl855 {
			yyb855 = yyj855 > l
		} else {
			yyb855 = r.CheckBreak()
		}
		if yyb855 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj855-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 {
		yym862 := z.EncBinary()
		_ = yym862
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep863 := !z.EncBinary()
			yy2arr863 := z.EncBasicHandle().StructToArray
			var yyq863 [4]bool
			_, _, _ = yysep863, yyq863, yy2arr863
			const yyr863 bool = false
			yyq863[1] = x.MinReadySeconds != 0
			yyq863[2] = x.Selector != nil
			yyq863[3] = true
			var yynn863 int
			if yyr863 || yy2arr863 {
				r.EncodeArrayStart(4)
			} else {
				yynn863 = 1
				for _, b := range yyq863 {
					if b {
						yynn863++
					}
				}
				r.EncodeMapStart(yynn863)
				yynn863 = 0
			}
			if yyr863 || yy2arr863 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym865 := z.EncBinary()
				_ = yym865
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym866 := z.EncBinary()
				_ = yym866
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr863 || yy2arr863 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq863[1] {
					yym868 := z.EncBinary()
					_ = yym868
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq863[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym869 := z.EncBinary()
					_ = yym869
					if false {
					} else {
						r.EncodeInt(int64(x.MinReadySeconds))
					}
				}
			}
			if yyr863 || yy2arr863 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq863[2] {
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym871 := z.EncBinary()
						_ = yym871
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq863[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("selector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Selector == nil {
						r.EncodeNil()
					} else {
						yym872 := z.EncBinary()
						_ = yym872
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Selector) {
						} else {
							z.EncFallback(x.Selector)
						}
					}
				}
			}
			if yyr863 || yy2arr863 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq863[3] {
					yy874 := &x.Template
					yy874.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq863[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("template"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy875 := &x.Template
					yy875.CodecEncodeSelf(e)
				}
			}
			if yyr863 || yy2arr863 {
				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
	yym876 := z.DecBinary()
	_ = yym876
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct877 := r.ContainerType()
		if yyct877 == codecSelferValueTypeMap1234 {
			yyl877 := r.ReadMapStart()
			if yyl877 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl877, d)
			}
		} else if yyct877 == codecSelferValueTypeArray1234 {
			yyl877 := r.ReadArrayStart()
			if yyl877 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl877, 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 yys878Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys878Slc
	var yyhl878 bool = l >= 0
	for yyj878 := 0; ; yyj878++ {
		if yyhl878 {
			if yyj878 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys878Slc = r.DecodeBytes(yys878Slc, true, true)
		yys878 := string(yys878Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys878 {
		case "replicas":
			if r.TryDecodeAsNil() {
				x.Replicas = 0
			} else {
				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(pkg1_unversioned.LabelSelector)
				}
				yym882 := z.DecBinary()
				_ = yym882
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Selector) {
				} else {
					z.DecFallback(x.Selector, false)
				}
			}
		case "template":
			if r.TryDecodeAsNil() {
				x.Template = pkg2_api.PodTemplateSpec{}
			} else {
				yyv883 := &x.Template
				yyv883.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys878)
		} // end switch yys878
	} // end for yyj878
	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 yyj884 int
	var yyb884 bool
	var yyhl884 bool = l >= 0
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.MinReadySeconds = 0
	} else {
		x.MinReadySeconds = int32(r.DecodeInt(32))
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym888 := z.DecBinary()
		_ = yym888
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Selector) {
		} else {
			z.DecFallback(x.Selector, false)
		}
	}
	yyj884++
	if yyhl884 {
		yyb884 = yyj884 > l
	} else {
		yyb884 = r.CheckBreak()
	}
	if yyb884 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Template = pkg2_api.PodTemplateSpec{}
	} else {
		yyv889 := &x.Template
		yyv889.CodecDecodeSelf(d)
	}
	for {
		yyj884++
		if yyhl884 {
			yyb884 = yyj884 > l
		} else {
			yyb884 = r.CheckBreak()
		}
		if yyb884 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj884-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 {
		yym890 := z.EncBinary()
		_ = yym890
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep891 := !z.EncBinary()
			yy2arr891 := z.EncBasicHandle().StructToArray
			var yyq891 [6]bool
			_, _, _ = yysep891, yyq891, yy2arr891
			const yyr891 bool = false
			yyq891[1] = x.FullyLabeledReplicas != 0
			yyq891[2] = x.ReadyReplicas != 0
			yyq891[3] = x.AvailableReplicas != 0
			yyq891[4] = x.ObservedGeneration != 0
			yyq891[5] = len(x.Conditions) != 0
			var yynn891 int
			if yyr891 || yy2arr891 {
				r.EncodeArrayStart(6)
			} else {
				yynn891 = 1
				for _, b := range yyq891 {
					if b {
						yynn891++
					}
				}
				r.EncodeMapStart(yynn891)
				yynn891 = 0
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym893 := z.EncBinary()
				_ = yym893
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("replicas"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym894 := z.EncBinary()
				_ = yym894
				if false {
				} else {
					r.EncodeInt(int64(x.Replicas))
				}
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq891[1] {
					yym896 := z.EncBinary()
					_ = yym896
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq891[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym897 := z.EncBinary()
					_ = yym897
					if false {
					} else {
						r.EncodeInt(int64(x.FullyLabeledReplicas))
					}
				}
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq891[2] {
					yym899 := z.EncBinary()
					_ = yym899
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq891[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym900 := z.EncBinary()
					_ = yym900
					if false {
					} else {
						r.EncodeInt(int64(x.ReadyReplicas))
					}
				}
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq891[3] {
					yym902 := z.EncBinary()
					_ = yym902
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq891[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym903 := z.EncBinary()
					_ = yym903
					if false {
					} else {
						r.EncodeInt(int64(x.AvailableReplicas))
					}
				}
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq891[4] {
					yym905 := z.EncBinary()
					_ = yym905
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				} else {
					r.EncodeInt(0)
				}
			} else {
				if yyq891[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym906 := z.EncBinary()
					_ = yym906
					if false {
					} else {
						r.EncodeInt(int64(x.ObservedGeneration))
					}
				}
			}
			if yyr891 || yy2arr891 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq891[5] {
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym908 := z.EncBinary()
						_ = yym908
						if false {
						} else {
							h.encSliceReplicaSetCondition(([]ReplicaSetCondition)(x.Conditions), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq891[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("conditions"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Conditions == nil {
						r.EncodeNil()
					} else {
						yym909 := z.EncBinary()
						_ = yym909
						if false {
						} else {
							h.encSliceReplicaSetCondition(([]ReplicaSetCondition)(x.Conditions), e)
						}
					}
				}
			}
			if yyr891 || yy2arr891 {
				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
	yym910 := z.DecBinary()
	_ = yym910
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct911 := r.ContainerType()
		if yyct911 == codecSelferValueTypeMap1234 {
			yyl911 := r.ReadMapStart()
			if yyl911 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl911, d)
			}
		} else if yyct911 == codecSelferValueTypeArray1234 {
			yyl911 := r.ReadArrayStart()
			if yyl911 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl911, 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 yys912Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys912Slc
	var yyhl912 bool = l >= 0
	for yyj912 := 0; ; yyj912++ {
		if yyhl912 {
			if yyj912 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys912Slc = r.DecodeBytes(yys912Slc, true, true)
		yys912 := string(yys912Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys912 {
		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 {
				yyv918 := &x.Conditions
				yym919 := z.DecBinary()
				_ = yym919
				if false {
				} else {
					h.decSliceReplicaSetCondition((*[]ReplicaSetCondition)(yyv918), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys912)
		} // end switch yys912
	} // end for yyj912
	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 yyj920 int
	var yyb920 bool
	var yyhl920 bool = l >= 0
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Replicas = 0
	} else {
		x.Replicas = int32(r.DecodeInt(32))
	}
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FullyLabeledReplicas = 0
	} else {
		x.FullyLabeledReplicas = int32(r.DecodeInt(32))
	}
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadyReplicas = 0
	} else {
		x.ReadyReplicas = int32(r.DecodeInt(32))
	}
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AvailableReplicas = 0
	} else {
		x.AvailableReplicas = int32(r.DecodeInt(32))
	}
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObservedGeneration = 0
	} else {
		x.ObservedGeneration = int64(r.DecodeInt(64))
	}
	yyj920++
	if yyhl920 {
		yyb920 = yyj920 > l
	} else {
		yyb920 = r.CheckBreak()
	}
	if yyb920 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Conditions = nil
	} else {
		yyv926 := &x.Conditions
		yym927 := z.DecBinary()
		_ = yym927
		if false {
		} else {
			h.decSliceReplicaSetCondition((*[]ReplicaSetCondition)(yyv926), d)
		}
	}
	for {
		yyj920++
		if yyhl920 {
			yyb920 = yyj920 > l
		} else {
			yyb920 = r.CheckBreak()
		}
		if yyb920 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj920-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

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

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

func (x *ReplicaSetCondition) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym930 := z.EncBinary()
		_ = yym930
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep931 := !z.EncBinary()
			yy2arr931 := z.EncBasicHandle().StructToArray
			var yyq931 [5]bool
			_, _, _ = yysep931, yyq931, yy2arr931
			const yyr931 bool = false
			yyq931[2] = true
			yyq931[3] = x.Reason != ""
			yyq931[4] = x.Message != ""
			var yynn931 int
			if yyr931 || yy2arr931 {
				r.EncodeArrayStart(5)
			} else {
				yynn931 = 2
				for _, b := range yyq931 {
					if b {
						yynn931++
					}
				}
				r.EncodeMapStart(yynn931)
				yynn931 = 0
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("type"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym934 := z.EncBinary()
				_ = yym934
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("status"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym935 := z.EncBinary()
				_ = yym935
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Status) {
				} else {
					r.EncodeString(codecSelferC_UTF81234, string(x.Status))
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[2] {
					yy937 := &x.LastTransitionTime
					yym938 := z.EncBinary()
					_ = yym938
					if false {
					} else if z.HasExtensions() && z.EncExt(yy937) {
					} else if yym938 {
						z.EncBinaryMarshal(yy937)
					} else if !yym938 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy937)
					} else {
						z.EncFallback(yy937)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq931[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy939 := &x.LastTransitionTime
					yym940 := z.EncBinary()
					_ = yym940
					if false {
					} else if z.HasExtensions() && z.EncExt(yy939) {
					} else if yym940 {
						z.EncBinaryMarshal(yy939)
					} else if !yym940 && z.IsJSONHandle() {
						z.EncJSONMarshal(yy939)
					} else {
						z.EncFallback(yy939)
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[3] {
					yym942 := z.EncBinary()
					_ = yym942
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq931[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym943 := z.EncBinary()
					_ = yym943
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr931 || yy2arr931 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq931[4] {
					yym945 := z.EncBinary()
					_ = yym945
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq931[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("message"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym946 := z.EncBinary()
					_ = yym946
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Message))
					}
				}
			}
			if yyr931 || yy2arr931 {
				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
	yym947 := z.DecBinary()
	_ = yym947
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct948 := r.ContainerType()
		if yyct948 == codecSelferValueTypeMap1234 {
			yyl948 := r.ReadMapStart()
			if yyl948 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl948, d)
			}
		} else if yyct948 == codecSelferValueTypeArray1234 {
			yyl948 := r.ReadArrayStart()
			if yyl948 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl948, 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 yys949Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys949Slc
	var yyhl949 bool = l >= 0
	for yyj949 := 0; ; yyj949++ {
		if yyhl949 {
			if yyj949 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys949Slc = r.DecodeBytes(yys949Slc, true, true)
		yys949 := string(yys949Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys949 {
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = ReplicaSetConditionType(r.DecodeString())
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = ""
			} else {
				x.Status = pkg2_api.ConditionStatus(r.DecodeString())
			}
		case "lastTransitionTime":
			if r.TryDecodeAsNil() {
				x.LastTransitionTime = pkg1_unversioned.Time{}
			} else {
				yyv952 := &x.LastTransitionTime
				yym953 := z.DecBinary()
				_ = yym953
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv952) {
				} else if yym953 {
					z.DecBinaryUnmarshal(yyv952)
				} else if !yym953 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(yyv952)
				} else {
					z.DecFallback(yyv952, 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, yys949)
		} // end switch yys949
	} // end for yyj949
	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 yyj956 int
	var yyb956 bool
	var yyhl956 bool = l >= 0
	yyj956++
	if yyhl956 {
		yyb956 = yyj956 > l
	} else {
		yyb956 = r.CheckBreak()
	}
	if yyb956 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = ReplicaSetConditionType(r.DecodeString())
	}
	yyj956++
	if yyhl956 {
		yyb956 = yyj956 > l
	} else {
		yyb956 = r.CheckBreak()
	}
	if yyb956 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = ""
	} else {
		x.Status = pkg2_api.ConditionStatus(r.DecodeString())
	}
	yyj956++
	if yyhl956 {
		yyb956 = yyj956 > l
	} else {
		yyb956 = r.CheckBreak()
	}
	if yyb956 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.LastTransitionTime = pkg1_unversioned.Time{}
	} else {
		yyv959 := &x.LastTransitionTime
		yym960 := z.DecBinary()
		_ = yym960
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv959) {
		} else if yym960 {
			z.DecBinaryUnmarshal(yyv959)
		} else if !yym960 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(yyv959)
		} else {
			z.DecFallback(yyv959, false)
		}
	}
	yyj956++
	if yyhl956 {
		yyb956 = yyj956 > l
	} else {
		yyb956 = r.CheckBreak()
	}
	if yyb956 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	yyj956++
	if yyhl956 {
		yyb956 = yyj956 > l
	} else {
		yyb956 = r.CheckBreak()
	}
	if yyb956 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Message = ""
	} else {
		x.Message = string(r.DecodeString())
	}
	for {
		yyj956++
		if yyhl956 {
			yyb956 = yyj956 > l
		} else {
			yyb956 = r.CheckBreak()
		}
		if yyb956 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj956-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 {
		yym963 := z.EncBinary()
		_ = yym963
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep964 := !z.EncBinary()
			yy2arr964 := z.EncBasicHandle().StructToArray
			var yyq964 [4]bool
			_, _, _ = yysep964, yyq964, yy2arr964
			const yyr964 bool = false
			yyq964[0] = x.Kind != ""
			yyq964[1] = x.APIVersion != ""
			yyq964[2] = true
			yyq964[3] = true
			var yynn964 int
			if yyr964 || yy2arr964 {
				r.EncodeArrayStart(4)
			} else {
				yynn964 = 0
				for _, b := range yyq964 {
					if b {
						yynn964++
					}
				}
				r.EncodeMapStart(yynn964)
				yynn964 = 0
			}
			if yyr964 || yy2arr964 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq964[0] {
					yym966 := z.EncBinary()
					_ = yym966
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq964[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym967 := z.EncBinary()
					_ = yym967
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr964 || yy2arr964 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq964[1] {
					yym969 := z.EncBinary()
					_ = yym969
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq964[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym970 := z.EncBinary()
					_ = yym970
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr964 || yy2arr964 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq964[2] {
					yy972 := &x.ObjectMeta
					yy972.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq964[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy973 := &x.ObjectMeta
					yy973.CodecEncodeSelf(e)
				}
			}
			if yyr964 || yy2arr964 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq964[3] {
					yy975 := &x.Spec
					yy975.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq964[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy976 := &x.Spec
					yy976.CodecEncodeSelf(e)
				}
			}
			if yyr964 || yy2arr964 {
				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
	yym977 := z.DecBinary()
	_ = yym977
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct978 := r.ContainerType()
		if yyct978 == codecSelferValueTypeMap1234 {
			yyl978 := r.ReadMapStart()
			if yyl978 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl978, d)
			}
		} else if yyct978 == codecSelferValueTypeArray1234 {
			yyl978 := r.ReadArrayStart()
			if yyl978 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl978, 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 yys979Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys979Slc
	var yyhl979 bool = l >= 0
	for yyj979 := 0; ; yyj979++ {
		if yyhl979 {
			if yyj979 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys979Slc = r.DecodeBytes(yys979Slc, true, true)
		yys979 := string(yys979Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys979 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv982 := &x.ObjectMeta
				yyv982.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = PodSecurityPolicySpec{}
			} else {
				yyv983 := &x.Spec
				yyv983.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys979)
		} // end switch yys979
	} // end for yyj979
	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 yyj984 int
	var yyb984 bool
	var yyhl984 bool = l >= 0
	yyj984++
	if yyhl984 {
		yyb984 = yyj984 > l
	} else {
		yyb984 = r.CheckBreak()
	}
	if yyb984 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj984++
	if yyhl984 {
		yyb984 = yyj984 > l
	} else {
		yyb984 = r.CheckBreak()
	}
	if yyb984 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj984++
	if yyhl984 {
		yyb984 = yyj984 > l
	} else {
		yyb984 = r.CheckBreak()
	}
	if yyb984 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv987 := &x.ObjectMeta
		yyv987.CodecDecodeSelf(d)
	}
	yyj984++
	if yyhl984 {
		yyb984 = yyj984 > l
	} else {
		yyb984 = r.CheckBreak()
	}
	if yyb984 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = PodSecurityPolicySpec{}
	} else {
		yyv988 := &x.Spec
		yyv988.CodecDecodeSelf(d)
	}
	for {
		yyj984++
		if yyhl984 {
			yyb984 = yyj984 > l
		} else {
			yyb984 = r.CheckBreak()
		}
		if yyb984 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj984-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 {
		yym989 := z.EncBinary()
		_ = yym989
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep990 := !z.EncBinary()
			yy2arr990 := z.EncBasicHandle().StructToArray
			var yyq990 [14]bool
			_, _, _ = yysep990, yyq990, yy2arr990
			const yyr990 bool = false
			yyq990[0] = x.Privileged != false
			yyq990[1] = len(x.DefaultAddCapabilities) != 0
			yyq990[2] = len(x.RequiredDropCapabilities) != 0
			yyq990[3] = len(x.AllowedCapabilities) != 0
			yyq990[4] = len(x.Volumes) != 0
			yyq990[5] = x.HostNetwork != false
			yyq990[6] = len(x.HostPorts) != 0
			yyq990[7] = x.HostPID != false
			yyq990[8] = x.HostIPC != false
			yyq990[13] = x.ReadOnlyRootFilesystem != false
			var yynn990 int
			if yyr990 || yy2arr990 {
				r.EncodeArrayStart(14)
			} else {
				yynn990 = 4
				for _, b := range yyq990 {
					if b {
						yynn990++
					}
				}
				r.EncodeMapStart(yynn990)
				yynn990 = 0
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[0] {
					yym992 := z.EncBinary()
					_ = yym992
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq990[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("privileged"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym993 := z.EncBinary()
					_ = yym993
					if false {
					} else {
						r.EncodeBool(bool(x.Privileged))
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[1] {
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym995 := z.EncBinary()
						_ = yym995
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq990[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("defaultAddCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.DefaultAddCapabilities == nil {
						r.EncodeNil()
					} else {
						yym996 := z.EncBinary()
						_ = yym996
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.DefaultAddCapabilities), e)
						}
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[2] {
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym998 := z.EncBinary()
						_ = yym998
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq990[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("requiredDropCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.RequiredDropCapabilities == nil {
						r.EncodeNil()
					} else {
						yym999 := z.EncBinary()
						_ = yym999
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.RequiredDropCapabilities), e)
						}
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[3] {
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1001 := z.EncBinary()
						_ = yym1001
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq990[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("allowedCapabilities"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.AllowedCapabilities == nil {
						r.EncodeNil()
					} else {
						yym1002 := z.EncBinary()
						_ = yym1002
						if false {
						} else {
							h.encSliceapi_Capability(([]pkg2_api.Capability)(x.AllowedCapabilities), e)
						}
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[4] {
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1004 := z.EncBinary()
						_ = yym1004
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq990[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("volumes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Volumes == nil {
						r.EncodeNil()
					} else {
						yym1005 := z.EncBinary()
						_ = yym1005
						if false {
						} else {
							h.encSliceFSType(([]FSType)(x.Volumes), e)
						}
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[5] {
					yym1007 := z.EncBinary()
					_ = yym1007
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq990[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostNetwork"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1008 := z.EncBinary()
					_ = yym1008
					if false {
					} else {
						r.EncodeBool(bool(x.HostNetwork))
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[6] {
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1010 := z.EncBinary()
						_ = yym1010
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq990[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPorts"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.HostPorts == nil {
						r.EncodeNil()
					} else {
						yym1011 := z.EncBinary()
						_ = yym1011
						if false {
						} else {
							h.encSliceHostPortRange(([]HostPortRange)(x.HostPorts), e)
						}
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[7] {
					yym1013 := z.EncBinary()
					_ = yym1013
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq990[7] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostPID"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1014 := z.EncBinary()
					_ = yym1014
					if false {
					} else {
						r.EncodeBool(bool(x.HostPID))
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[8] {
					yym1016 := z.EncBinary()
					_ = yym1016
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq990[8] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("hostIPC"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1017 := z.EncBinary()
					_ = yym1017
					if false {
					} else {
						r.EncodeBool(bool(x.HostIPC))
					}
				}
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1019 := &x.SELinux
				yy1019.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("seLinux"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1020 := &x.SELinux
				yy1020.CodecEncodeSelf(e)
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1022 := &x.RunAsUser
				yy1022.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1023 := &x.RunAsUser
				yy1023.CodecEncodeSelf(e)
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1025 := &x.SupplementalGroups
				yy1025.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1026 := &x.SupplementalGroups
				yy1026.CodecEncodeSelf(e)
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1028 := &x.FSGroup
				yy1028.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("fsGroup"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1029 := &x.FSGroup
				yy1029.CodecEncodeSelf(e)
			}
			if yyr990 || yy2arr990 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq990[13] {
					yym1031 := z.EncBinary()
					_ = yym1031
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				} else {
					r.EncodeBool(false)
				}
			} else {
				if yyq990[13] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1032 := z.EncBinary()
					_ = yym1032
					if false {
					} else {
						r.EncodeBool(bool(x.ReadOnlyRootFilesystem))
					}
				}
			}
			if yyr990 || yy2arr990 {
				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
	yym1033 := z.DecBinary()
	_ = yym1033
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1034 := r.ContainerType()
		if yyct1034 == codecSelferValueTypeMap1234 {
			yyl1034 := r.ReadMapStart()
			if yyl1034 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1034, d)
			}
		} else if yyct1034 == codecSelferValueTypeArray1234 {
			yyl1034 := r.ReadArrayStart()
			if yyl1034 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1034, 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 yys1035Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1035Slc
	var yyhl1035 bool = l >= 0
	for yyj1035 := 0; ; yyj1035++ {
		if yyhl1035 {
			if yyj1035 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1035Slc = r.DecodeBytes(yys1035Slc, true, true)
		yys1035 := string(yys1035Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1035 {
		case "privileged":
			if r.TryDecodeAsNil() {
				x.Privileged = false
			} else {
				x.Privileged = bool(r.DecodeBool())
			}
		case "defaultAddCapabilities":
			if r.TryDecodeAsNil() {
				x.DefaultAddCapabilities = nil
			} else {
				yyv1037 := &x.DefaultAddCapabilities
				yym1038 := z.DecBinary()
				_ = yym1038
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1037), d)
				}
			}
		case "requiredDropCapabilities":
			if r.TryDecodeAsNil() {
				x.RequiredDropCapabilities = nil
			} else {
				yyv1039 := &x.RequiredDropCapabilities
				yym1040 := z.DecBinary()
				_ = yym1040
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1039), d)
				}
			}
		case "allowedCapabilities":
			if r.TryDecodeAsNil() {
				x.AllowedCapabilities = nil
			} else {
				yyv1041 := &x.AllowedCapabilities
				yym1042 := z.DecBinary()
				_ = yym1042
				if false {
				} else {
					h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1041), d)
				}
			}
		case "volumes":
			if r.TryDecodeAsNil() {
				x.Volumes = nil
			} else {
				yyv1043 := &x.Volumes
				yym1044 := z.DecBinary()
				_ = yym1044
				if false {
				} else {
					h.decSliceFSType((*[]FSType)(yyv1043), d)
				}
			}
		case "hostNetwork":
			if r.TryDecodeAsNil() {
				x.HostNetwork = false
			} else {
				x.HostNetwork = bool(r.DecodeBool())
			}
		case "hostPorts":
			if r.TryDecodeAsNil() {
				x.HostPorts = nil
			} else {
				yyv1046 := &x.HostPorts
				yym1047 := z.DecBinary()
				_ = yym1047
				if false {
				} else {
					h.decSliceHostPortRange((*[]HostPortRange)(yyv1046), 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 {
				yyv1050 := &x.SELinux
				yyv1050.CodecDecodeSelf(d)
			}
		case "runAsUser":
			if r.TryDecodeAsNil() {
				x.RunAsUser = RunAsUserStrategyOptions{}
			} else {
				yyv1051 := &x.RunAsUser
				yyv1051.CodecDecodeSelf(d)
			}
		case "supplementalGroups":
			if r.TryDecodeAsNil() {
				x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
			} else {
				yyv1052 := &x.SupplementalGroups
				yyv1052.CodecDecodeSelf(d)
			}
		case "fsGroup":
			if r.TryDecodeAsNil() {
				x.FSGroup = FSGroupStrategyOptions{}
			} else {
				yyv1053 := &x.FSGroup
				yyv1053.CodecDecodeSelf(d)
			}
		case "readOnlyRootFilesystem":
			if r.TryDecodeAsNil() {
				x.ReadOnlyRootFilesystem = false
			} else {
				x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys1035)
		} // end switch yys1035
	} // end for yyj1035
	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 yyj1055 int
	var yyb1055 bool
	var yyhl1055 bool = l >= 0
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Privileged = false
	} else {
		x.Privileged = bool(r.DecodeBool())
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.DefaultAddCapabilities = nil
	} else {
		yyv1057 := &x.DefaultAddCapabilities
		yym1058 := z.DecBinary()
		_ = yym1058
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1057), d)
		}
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RequiredDropCapabilities = nil
	} else {
		yyv1059 := &x.RequiredDropCapabilities
		yym1060 := z.DecBinary()
		_ = yym1060
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1059), d)
		}
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.AllowedCapabilities = nil
	} else {
		yyv1061 := &x.AllowedCapabilities
		yym1062 := z.DecBinary()
		_ = yym1062
		if false {
		} else {
			h.decSliceapi_Capability((*[]pkg2_api.Capability)(yyv1061), d)
		}
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Volumes = nil
	} else {
		yyv1063 := &x.Volumes
		yym1064 := z.DecBinary()
		_ = yym1064
		if false {
		} else {
			h.decSliceFSType((*[]FSType)(yyv1063), d)
		}
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostNetwork = false
	} else {
		x.HostNetwork = bool(r.DecodeBool())
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPorts = nil
	} else {
		yyv1066 := &x.HostPorts
		yym1067 := z.DecBinary()
		_ = yym1067
		if false {
		} else {
			h.decSliceHostPortRange((*[]HostPortRange)(yyv1066), d)
		}
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostPID = false
	} else {
		x.HostPID = bool(r.DecodeBool())
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.HostIPC = false
	} else {
		x.HostIPC = bool(r.DecodeBool())
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SELinux = SELinuxStrategyOptions{}
	} else {
		yyv1070 := &x.SELinux
		yyv1070.CodecDecodeSelf(d)
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.RunAsUser = RunAsUserStrategyOptions{}
	} else {
		yyv1071 := &x.RunAsUser
		yyv1071.CodecDecodeSelf(d)
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.SupplementalGroups = SupplementalGroupsStrategyOptions{}
	} else {
		yyv1072 := &x.SupplementalGroups
		yyv1072.CodecDecodeSelf(d)
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.FSGroup = FSGroupStrategyOptions{}
	} else {
		yyv1073 := &x.FSGroup
		yyv1073.CodecDecodeSelf(d)
	}
	yyj1055++
	if yyhl1055 {
		yyb1055 = yyj1055 > l
	} else {
		yyb1055 = r.CheckBreak()
	}
	if yyb1055 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ReadOnlyRootFilesystem = false
	} else {
		x.ReadOnlyRootFilesystem = bool(r.DecodeBool())
	}
	for {
		yyj1055++
		if yyhl1055 {
			yyb1055 = yyj1055 > l
		} else {
			yyb1055 = r.CheckBreak()
		}
		if yyb1055 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1055-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *HostPortRange) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1075 := z.EncBinary()
		_ = yym1075
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1076 := !z.EncBinary()
			yy2arr1076 := z.EncBasicHandle().StructToArray
			var yyq1076 [2]bool
			_, _, _ = yysep1076, yyq1076, yy2arr1076
			const yyr1076 bool = false
			var yynn1076 int
			if yyr1076 || yy2arr1076 {
				r.EncodeArrayStart(2)
			} else {
				yynn1076 = 2
				for _, b := range yyq1076 {
					if b {
						yynn1076++
					}
				}
				r.EncodeMapStart(yynn1076)
				yynn1076 = 0
			}
			if yyr1076 || yy2arr1076 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1078 := z.EncBinary()
				_ = yym1078
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1079 := z.EncBinary()
				_ = yym1079
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1076 || yy2arr1076 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1081 := z.EncBinary()
				_ = yym1081
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1082 := z.EncBinary()
				_ = yym1082
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1076 || yy2arr1076 {
				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
	yym1083 := z.DecBinary()
	_ = yym1083
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1084 := r.ContainerType()
		if yyct1084 == codecSelferValueTypeMap1234 {
			yyl1084 := r.ReadMapStart()
			if yyl1084 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1084, d)
			}
		} else if yyct1084 == codecSelferValueTypeArray1234 {
			yyl1084 := r.ReadArrayStart()
			if yyl1084 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1084, 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 yys1085Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1085Slc
	var yyhl1085 bool = l >= 0
	for yyj1085 := 0; ; yyj1085++ {
		if yyhl1085 {
			if yyj1085 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1085Slc = r.DecodeBytes(yys1085Slc, true, true)
		yys1085 := string(yys1085Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1085 {
		case "min":
			if r.TryDecodeAsNil() {
				x.Min = 0
			} else {
				x.Min = int(r.DecodeInt(codecSelferBitsize1234))
			}
		case "max":
			if r.TryDecodeAsNil() {
				x.Max = 0
			} else {
				x.Max = int(r.DecodeInt(codecSelferBitsize1234))
			}
		default:
			z.DecStructFieldNotFound(-1, yys1085)
		} // end switch yys1085
	} // end for yyj1085
	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 yyj1088 int
	var yyb1088 bool
	var yyhl1088 bool = l >= 0
	yyj1088++
	if yyhl1088 {
		yyb1088 = yyj1088 > l
	} else {
		yyb1088 = r.CheckBreak()
	}
	if yyb1088 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int(r.DecodeInt(codecSelferBitsize1234))
	}
	yyj1088++
	if yyhl1088 {
		yyb1088 = yyj1088 > l
	} else {
		yyb1088 = r.CheckBreak()
	}
	if yyb1088 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int(r.DecodeInt(codecSelferBitsize1234))
	}
	for {
		yyj1088++
		if yyhl1088 {
			yyb1088 = yyj1088 > l
		} else {
			yyb1088 = r.CheckBreak()
		}
		if yyb1088 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1088-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1091 := z.EncBinary()
	_ = yym1091
	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
	yym1092 := z.DecBinary()
	_ = yym1092
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		*((*string)(x)) = r.DecodeString()
	}
}

func (x *SELinuxStrategyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1093 := z.EncBinary()
		_ = yym1093
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1094 := !z.EncBinary()
			yy2arr1094 := z.EncBasicHandle().StructToArray
			var yyq1094 [2]bool
			_, _, _ = yysep1094, yyq1094, yy2arr1094
			const yyr1094 bool = false
			yyq1094[1] = x.SELinuxOptions != nil
			var yynn1094 int
			if yyr1094 || yy2arr1094 {
				r.EncodeArrayStart(2)
			} else {
				yynn1094 = 1
				for _, b := range yyq1094 {
					if b {
						yynn1094++
					}
				}
				r.EncodeMapStart(yynn1094)
				yynn1094 = 0
			}
			if yyr1094 || yy2arr1094 {
				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 yyr1094 || yy2arr1094 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1094[1] {
					if x.SELinuxOptions == nil {
						r.EncodeNil()
					} else {
						x.SELinuxOptions.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1094[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 yyr1094 || yy2arr1094 {
				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
	yym1097 := z.DecBinary()
	_ = yym1097
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1098 := r.ContainerType()
		if yyct1098 == codecSelferValueTypeMap1234 {
			yyl1098 := r.ReadMapStart()
			if yyl1098 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1098, d)
			}
		} else if yyct1098 == codecSelferValueTypeArray1234 {
			yyl1098 := r.ReadArrayStart()
			if yyl1098 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1098, 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 yys1099Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1099Slc
	var yyhl1099 bool = l >= 0
	for yyj1099 := 0; ; yyj1099++ {
		if yyhl1099 {
			if yyj1099 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1099Slc = r.DecodeBytes(yys1099Slc, true, true)
		yys1099 := string(yys1099Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1099 {
		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_api.SELinuxOptions)
				}
				x.SELinuxOptions.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1099)
		} // end switch yys1099
	} // end for yyj1099
	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 yyj1102 int
	var yyb1102 bool
	var yyhl1102 bool = l >= 0
	yyj1102++
	if yyhl1102 {
		yyb1102 = yyj1102 > l
	} else {
		yyb1102 = r.CheckBreak()
	}
	if yyb1102 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SELinuxStrategy(r.DecodeString())
	}
	yyj1102++
	if yyhl1102 {
		yyb1102 = yyj1102 > l
	} else {
		yyb1102 = r.CheckBreak()
	}
	if yyb1102 {
		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_api.SELinuxOptions)
		}
		x.SELinuxOptions.CodecDecodeSelf(d)
	}
	for {
		yyj1102++
		if yyhl1102 {
			yyb1102 = yyj1102 > l
		} else {
			yyb1102 = r.CheckBreak()
		}
		if yyb1102 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1102-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SELinuxStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1105 := z.EncBinary()
	_ = yym1105
	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
	yym1106 := z.DecBinary()
	_ = yym1106
	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 {
		yym1107 := z.EncBinary()
		_ = yym1107
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1108 := !z.EncBinary()
			yy2arr1108 := z.EncBasicHandle().StructToArray
			var yyq1108 [2]bool
			_, _, _ = yysep1108, yyq1108, yy2arr1108
			const yyr1108 bool = false
			yyq1108[1] = len(x.Ranges) != 0
			var yynn1108 int
			if yyr1108 || yy2arr1108 {
				r.EncodeArrayStart(2)
			} else {
				yynn1108 = 1
				for _, b := range yyq1108 {
					if b {
						yynn1108++
					}
				}
				r.EncodeMapStart(yynn1108)
				yynn1108 = 0
			}
			if yyr1108 || yy2arr1108 {
				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 yyr1108 || yy2arr1108 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1108[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1111 := z.EncBinary()
						_ = yym1111
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1108[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1112 := z.EncBinary()
						_ = yym1112
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1108 || yy2arr1108 {
				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
	yym1113 := z.DecBinary()
	_ = yym1113
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1114 := r.ContainerType()
		if yyct1114 == codecSelferValueTypeMap1234 {
			yyl1114 := r.ReadMapStart()
			if yyl1114 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1114, d)
			}
		} else if yyct1114 == codecSelferValueTypeArray1234 {
			yyl1114 := r.ReadArrayStart()
			if yyl1114 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1114, 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 yys1115Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1115Slc
	var yyhl1115 bool = l >= 0
	for yyj1115 := 0; ; yyj1115++ {
		if yyhl1115 {
			if yyj1115 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1115Slc = r.DecodeBytes(yys1115Slc, true, true)
		yys1115 := string(yys1115Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1115 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = RunAsUserStrategy(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1117 := &x.Ranges
				yym1118 := z.DecBinary()
				_ = yym1118
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1117), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1115)
		} // end switch yys1115
	} // end for yyj1115
	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 yyj1119 int
	var yyb1119 bool
	var yyhl1119 bool = l >= 0
	yyj1119++
	if yyhl1119 {
		yyb1119 = yyj1119 > l
	} else {
		yyb1119 = r.CheckBreak()
	}
	if yyb1119 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = RunAsUserStrategy(r.DecodeString())
	}
	yyj1119++
	if yyhl1119 {
		yyb1119 = yyj1119 > l
	} else {
		yyb1119 = r.CheckBreak()
	}
	if yyb1119 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1121 := &x.Ranges
		yym1122 := z.DecBinary()
		_ = yym1122
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1121), d)
		}
	}
	for {
		yyj1119++
		if yyhl1119 {
			yyb1119 = yyj1119 > l
		} else {
			yyb1119 = r.CheckBreak()
		}
		if yyb1119 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1119-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 {
		yym1123 := z.EncBinary()
		_ = yym1123
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1124 := !z.EncBinary()
			yy2arr1124 := z.EncBasicHandle().StructToArray
			var yyq1124 [2]bool
			_, _, _ = yysep1124, yyq1124, yy2arr1124
			const yyr1124 bool = false
			var yynn1124 int
			if yyr1124 || yy2arr1124 {
				r.EncodeArrayStart(2)
			} else {
				yynn1124 = 2
				for _, b := range yyq1124 {
					if b {
						yynn1124++
					}
				}
				r.EncodeMapStart(yynn1124)
				yynn1124 = 0
			}
			if yyr1124 || yy2arr1124 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1126 := z.EncBinary()
				_ = yym1126
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("min"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1127 := z.EncBinary()
				_ = yym1127
				if false {
				} else {
					r.EncodeInt(int64(x.Min))
				}
			}
			if yyr1124 || yy2arr1124 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym1129 := z.EncBinary()
				_ = yym1129
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("max"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym1130 := z.EncBinary()
				_ = yym1130
				if false {
				} else {
					r.EncodeInt(int64(x.Max))
				}
			}
			if yyr1124 || yy2arr1124 {
				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
	yym1131 := z.DecBinary()
	_ = yym1131
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1132 := r.ContainerType()
		if yyct1132 == codecSelferValueTypeMap1234 {
			yyl1132 := r.ReadMapStart()
			if yyl1132 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1132, d)
			}
		} else if yyct1132 == codecSelferValueTypeArray1234 {
			yyl1132 := r.ReadArrayStart()
			if yyl1132 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1132, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *IDRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1133Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1133Slc
	var yyhl1133 bool = l >= 0
	for yyj1133 := 0; ; yyj1133++ {
		if yyhl1133 {
			if yyj1133 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1133Slc = r.DecodeBytes(yys1133Slc, true, true)
		yys1133 := string(yys1133Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1133 {
		case "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, yys1133)
		} // end switch yys1133
	} // end for yyj1133
	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 yyj1136 int
	var yyb1136 bool
	var yyhl1136 bool = l >= 0
	yyj1136++
	if yyhl1136 {
		yyb1136 = yyj1136 > l
	} else {
		yyb1136 = r.CheckBreak()
	}
	if yyb1136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Min = 0
	} else {
		x.Min = int64(r.DecodeInt(64))
	}
	yyj1136++
	if yyhl1136 {
		yyb1136 = yyj1136 > l
	} else {
		yyb1136 = r.CheckBreak()
	}
	if yyb1136 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Max = 0
	} else {
		x.Max = int64(r.DecodeInt(64))
	}
	for {
		yyj1136++
		if yyhl1136 {
			yyb1136 = yyj1136 > l
		} else {
			yyb1136 = r.CheckBreak()
		}
		if yyb1136 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1136-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x RunAsUserStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1139 := z.EncBinary()
	_ = yym1139
	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
	yym1140 := z.DecBinary()
	_ = yym1140
	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 {
		yym1141 := z.EncBinary()
		_ = yym1141
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1142 := !z.EncBinary()
			yy2arr1142 := z.EncBasicHandle().StructToArray
			var yyq1142 [2]bool
			_, _, _ = yysep1142, yyq1142, yy2arr1142
			const yyr1142 bool = false
			yyq1142[0] = x.Rule != ""
			yyq1142[1] = len(x.Ranges) != 0
			var yynn1142 int
			if yyr1142 || yy2arr1142 {
				r.EncodeArrayStart(2)
			} else {
				yynn1142 = 0
				for _, b := range yyq1142 {
					if b {
						yynn1142++
					}
				}
				r.EncodeMapStart(yynn1142)
				yynn1142 = 0
			}
			if yyr1142 || yy2arr1142 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1142[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1142[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1142 || yy2arr1142 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1142[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1145 := z.EncBinary()
						_ = yym1145
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1142[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1146 := z.EncBinary()
						_ = yym1146
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1142 || yy2arr1142 {
				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
	yym1147 := z.DecBinary()
	_ = yym1147
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1148 := r.ContainerType()
		if yyct1148 == codecSelferValueTypeMap1234 {
			yyl1148 := r.ReadMapStart()
			if yyl1148 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1148, d)
			}
		} else if yyct1148 == codecSelferValueTypeArray1234 {
			yyl1148 := r.ReadArrayStart()
			if yyl1148 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1148, 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 yys1149Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1149Slc
	var yyhl1149 bool = l >= 0
	for yyj1149 := 0; ; yyj1149++ {
		if yyhl1149 {
			if yyj1149 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1149Slc = r.DecodeBytes(yys1149Slc, true, true)
		yys1149 := string(yys1149Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1149 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = FSGroupStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1151 := &x.Ranges
				yym1152 := z.DecBinary()
				_ = yym1152
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1151), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1149)
		} // end switch yys1149
	} // end for yyj1149
	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 yyj1153 int
	var yyb1153 bool
	var yyhl1153 bool = l >= 0
	yyj1153++
	if yyhl1153 {
		yyb1153 = yyj1153 > l
	} else {
		yyb1153 = r.CheckBreak()
	}
	if yyb1153 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = FSGroupStrategyType(r.DecodeString())
	}
	yyj1153++
	if yyhl1153 {
		yyb1153 = yyj1153 > l
	} else {
		yyb1153 = r.CheckBreak()
	}
	if yyb1153 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1155 := &x.Ranges
		yym1156 := z.DecBinary()
		_ = yym1156
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1155), d)
		}
	}
	for {
		yyj1153++
		if yyhl1153 {
			yyb1153 = yyj1153 > l
		} else {
			yyb1153 = r.CheckBreak()
		}
		if yyb1153 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1153-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x FSGroupStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1157 := z.EncBinary()
	_ = yym1157
	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
	yym1158 := z.DecBinary()
	_ = yym1158
	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 {
		yym1159 := z.EncBinary()
		_ = yym1159
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1160 := !z.EncBinary()
			yy2arr1160 := z.EncBasicHandle().StructToArray
			var yyq1160 [2]bool
			_, _, _ = yysep1160, yyq1160, yy2arr1160
			const yyr1160 bool = false
			yyq1160[0] = x.Rule != ""
			yyq1160[1] = len(x.Ranges) != 0
			var yynn1160 int
			if yyr1160 || yy2arr1160 {
				r.EncodeArrayStart(2)
			} else {
				yynn1160 = 0
				for _, b := range yyq1160 {
					if b {
						yynn1160++
					}
				}
				r.EncodeMapStart(yynn1160)
				yynn1160 = 0
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1160[0] {
					x.Rule.CodecEncodeSelf(e)
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1160[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("rule"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					x.Rule.CodecEncodeSelf(e)
				}
			}
			if yyr1160 || yy2arr1160 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1160[1] {
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1163 := z.EncBinary()
						_ = yym1163
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1160[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ranges"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ranges == nil {
						r.EncodeNil()
					} else {
						yym1164 := z.EncBinary()
						_ = yym1164
						if false {
						} else {
							h.encSliceIDRange(([]IDRange)(x.Ranges), e)
						}
					}
				}
			}
			if yyr1160 || yy2arr1160 {
				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
	yym1165 := z.DecBinary()
	_ = yym1165
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1166 := r.ContainerType()
		if yyct1166 == codecSelferValueTypeMap1234 {
			yyl1166 := r.ReadMapStart()
			if yyl1166 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1166, d)
			}
		} else if yyct1166 == codecSelferValueTypeArray1234 {
			yyl1166 := r.ReadArrayStart()
			if yyl1166 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1166, 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 yys1167Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1167Slc
	var yyhl1167 bool = l >= 0
	for yyj1167 := 0; ; yyj1167++ {
		if yyhl1167 {
			if yyj1167 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1167Slc = r.DecodeBytes(yys1167Slc, true, true)
		yys1167 := string(yys1167Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1167 {
		case "rule":
			if r.TryDecodeAsNil() {
				x.Rule = ""
			} else {
				x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
			}
		case "ranges":
			if r.TryDecodeAsNil() {
				x.Ranges = nil
			} else {
				yyv1169 := &x.Ranges
				yym1170 := z.DecBinary()
				_ = yym1170
				if false {
				} else {
					h.decSliceIDRange((*[]IDRange)(yyv1169), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1167)
		} // end switch yys1167
	} // end for yyj1167
	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 yyj1171 int
	var yyb1171 bool
	var yyhl1171 bool = l >= 0
	yyj1171++
	if yyhl1171 {
		yyb1171 = yyj1171 > l
	} else {
		yyb1171 = r.CheckBreak()
	}
	if yyb1171 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Rule = ""
	} else {
		x.Rule = SupplementalGroupsStrategyType(r.DecodeString())
	}
	yyj1171++
	if yyhl1171 {
		yyb1171 = yyj1171 > l
	} else {
		yyb1171 = r.CheckBreak()
	}
	if yyb1171 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ranges = nil
	} else {
		yyv1173 := &x.Ranges
		yym1174 := z.DecBinary()
		_ = yym1174
		if false {
		} else {
			h.decSliceIDRange((*[]IDRange)(yyv1173), d)
		}
	}
	for {
		yyj1171++
		if yyhl1171 {
			yyb1171 = yyj1171 > l
		} else {
			yyb1171 = r.CheckBreak()
		}
		if yyb1171 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1171-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x SupplementalGroupsStrategyType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1175 := z.EncBinary()
	_ = yym1175
	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
	yym1176 := z.DecBinary()
	_ = yym1176
	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 {
		yym1177 := z.EncBinary()
		_ = yym1177
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1178 := !z.EncBinary()
			yy2arr1178 := z.EncBasicHandle().StructToArray
			var yyq1178 [4]bool
			_, _, _ = yysep1178, yyq1178, yy2arr1178
			const yyr1178 bool = false
			yyq1178[0] = x.Kind != ""
			yyq1178[1] = x.APIVersion != ""
			yyq1178[2] = true
			var yynn1178 int
			if yyr1178 || yy2arr1178 {
				r.EncodeArrayStart(4)
			} else {
				yynn1178 = 1
				for _, b := range yyq1178 {
					if b {
						yynn1178++
					}
				}
				r.EncodeMapStart(yynn1178)
				yynn1178 = 0
			}
			if yyr1178 || yy2arr1178 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1178[0] {
					yym1180 := z.EncBinary()
					_ = yym1180
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1178[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1181 := z.EncBinary()
					_ = yym1181
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1178 || yy2arr1178 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1178[1] {
					yym1183 := z.EncBinary()
					_ = yym1183
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1178[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1184 := z.EncBinary()
					_ = yym1184
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1178 || yy2arr1178 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1178[2] {
					yy1186 := &x.ListMeta
					yym1187 := z.EncBinary()
					_ = yym1187
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1186) {
					} else {
						z.EncFallback(yy1186)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1178[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1188 := &x.ListMeta
					yym1189 := z.EncBinary()
					_ = yym1189
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1188) {
					} else {
						z.EncFallback(yy1188)
					}
				}
			}
			if yyr1178 || yy2arr1178 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1191 := z.EncBinary()
					_ = yym1191
					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 {
					yym1192 := z.EncBinary()
					_ = yym1192
					if false {
					} else {
						h.encSlicePodSecurityPolicy(([]PodSecurityPolicy)(x.Items), e)
					}
				}
			}
			if yyr1178 || yy2arr1178 {
				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
	yym1193 := z.DecBinary()
	_ = yym1193
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1194 := r.ContainerType()
		if yyct1194 == codecSelferValueTypeMap1234 {
			yyl1194 := r.ReadMapStart()
			if yyl1194 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1194, d)
			}
		} else if yyct1194 == codecSelferValueTypeArray1234 {
			yyl1194 := r.ReadArrayStart()
			if yyl1194 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1194, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *PodSecurityPolicyList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1195Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1195Slc
	var yyhl1195 bool = l >= 0
	for yyj1195 := 0; ; yyj1195++ {
		if yyhl1195 {
			if yyj1195 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1195Slc = r.DecodeBytes(yys1195Slc, true, true)
		yys1195 := string(yys1195Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1195 {
		case "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 {
				yyv1198 := &x.ListMeta
				yym1199 := z.DecBinary()
				_ = yym1199
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1198) {
				} else {
					z.DecFallback(yyv1198, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1200 := &x.Items
				yym1201 := z.DecBinary()
				_ = yym1201
				if false {
				} else {
					h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1200), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1195)
		} // end switch yys1195
	} // end for yyj1195
	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 yyj1202 int
	var yyb1202 bool
	var yyhl1202 bool = l >= 0
	yyj1202++
	if yyhl1202 {
		yyb1202 = yyj1202 > l
	} else {
		yyb1202 = r.CheckBreak()
	}
	if yyb1202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1202++
	if yyhl1202 {
		yyb1202 = yyj1202 > l
	} else {
		yyb1202 = r.CheckBreak()
	}
	if yyb1202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1202++
	if yyhl1202 {
		yyb1202 = yyj1202 > l
	} else {
		yyb1202 = r.CheckBreak()
	}
	if yyb1202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1205 := &x.ListMeta
		yym1206 := z.DecBinary()
		_ = yym1206
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1205) {
		} else {
			z.DecFallback(yyv1205, false)
		}
	}
	yyj1202++
	if yyhl1202 {
		yyb1202 = yyj1202 > l
	} else {
		yyb1202 = r.CheckBreak()
	}
	if yyb1202 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1207 := &x.Items
		yym1208 := z.DecBinary()
		_ = yym1208
		if false {
		} else {
			h.decSlicePodSecurityPolicy((*[]PodSecurityPolicy)(yyv1207), d)
		}
	}
	for {
		yyj1202++
		if yyhl1202 {
			yyb1202 = yyj1202 > l
		} else {
			yyb1202 = r.CheckBreak()
		}
		if yyb1202 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1202-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 {
		yym1209 := z.EncBinary()
		_ = yym1209
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1210 := !z.EncBinary()
			yy2arr1210 := z.EncBasicHandle().StructToArray
			var yyq1210 [4]bool
			_, _, _ = yysep1210, yyq1210, yy2arr1210
			const yyr1210 bool = false
			yyq1210[0] = x.Kind != ""
			yyq1210[1] = x.APIVersion != ""
			yyq1210[2] = true
			yyq1210[3] = true
			var yynn1210 int
			if yyr1210 || yy2arr1210 {
				r.EncodeArrayStart(4)
			} else {
				yynn1210 = 0
				for _, b := range yyq1210 {
					if b {
						yynn1210++
					}
				}
				r.EncodeMapStart(yynn1210)
				yynn1210 = 0
			}
			if yyr1210 || yy2arr1210 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1210[0] {
					yym1212 := z.EncBinary()
					_ = yym1212
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1210[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1213 := z.EncBinary()
					_ = yym1213
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1210 || yy2arr1210 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1210[1] {
					yym1215 := z.EncBinary()
					_ = yym1215
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1210[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1216 := z.EncBinary()
					_ = yym1216
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1210 || yy2arr1210 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1210[2] {
					yy1218 := &x.ObjectMeta
					yy1218.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1210[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1219 := &x.ObjectMeta
					yy1219.CodecEncodeSelf(e)
				}
			}
			if yyr1210 || yy2arr1210 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1210[3] {
					yy1221 := &x.Spec
					yy1221.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1210[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("spec"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1222 := &x.Spec
					yy1222.CodecEncodeSelf(e)
				}
			}
			if yyr1210 || yy2arr1210 {
				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
	yym1223 := z.DecBinary()
	_ = yym1223
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1224 := r.ContainerType()
		if yyct1224 == codecSelferValueTypeMap1234 {
			yyl1224 := r.ReadMapStart()
			if yyl1224 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1224, d)
			}
		} else if yyct1224 == codecSelferValueTypeArray1234 {
			yyl1224 := r.ReadArrayStart()
			if yyl1224 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1224, 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 yys1225Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1225Slc
	var yyhl1225 bool = l >= 0
	for yyj1225 := 0; ; yyj1225++ {
		if yyhl1225 {
			if yyj1225 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1225Slc = r.DecodeBytes(yys1225Slc, true, true)
		yys1225 := string(yys1225Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1225 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "metadata":
			if r.TryDecodeAsNil() {
				x.ObjectMeta = pkg2_api.ObjectMeta{}
			} else {
				yyv1228 := &x.ObjectMeta
				yyv1228.CodecDecodeSelf(d)
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = NetworkPolicySpec{}
			} else {
				yyv1229 := &x.Spec
				yyv1229.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys1225)
		} // end switch yys1225
	} // end for yyj1225
	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 yyj1230 int
	var yyb1230 bool
	var yyhl1230 bool = l >= 0
	yyj1230++
	if yyhl1230 {
		yyb1230 = yyj1230 > l
	} else {
		yyb1230 = r.CheckBreak()
	}
	if yyb1230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1230++
	if yyhl1230 {
		yyb1230 = yyj1230 > l
	} else {
		yyb1230 = r.CheckBreak()
	}
	if yyb1230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1230++
	if yyhl1230 {
		yyb1230 = yyj1230 > l
	} else {
		yyb1230 = r.CheckBreak()
	}
	if yyb1230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ObjectMeta = pkg2_api.ObjectMeta{}
	} else {
		yyv1233 := &x.ObjectMeta
		yyv1233.CodecDecodeSelf(d)
	}
	yyj1230++
	if yyhl1230 {
		yyb1230 = yyj1230 > l
	} else {
		yyb1230 = r.CheckBreak()
	}
	if yyb1230 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = NetworkPolicySpec{}
	} else {
		yyv1234 := &x.Spec
		yyv1234.CodecDecodeSelf(d)
	}
	for {
		yyj1230++
		if yyhl1230 {
			yyb1230 = yyj1230 > l
		} else {
			yyb1230 = r.CheckBreak()
		}
		if yyb1230 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1230-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 {
		yym1235 := z.EncBinary()
		_ = yym1235
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1236 := !z.EncBinary()
			yy2arr1236 := z.EncBasicHandle().StructToArray
			var yyq1236 [2]bool
			_, _, _ = yysep1236, yyq1236, yy2arr1236
			const yyr1236 bool = false
			yyq1236[1] = len(x.Ingress) != 0
			var yynn1236 int
			if yyr1236 || yy2arr1236 {
				r.EncodeArrayStart(2)
			} else {
				yynn1236 = 1
				for _, b := range yyq1236 {
					if b {
						yynn1236++
					}
				}
				r.EncodeMapStart(yynn1236)
				yynn1236 = 0
			}
			if yyr1236 || yy2arr1236 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy1238 := &x.PodSelector
				yym1239 := z.EncBinary()
				_ = yym1239
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1238) {
				} else {
					z.EncFallback(yy1238)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy1240 := &x.PodSelector
				yym1241 := z.EncBinary()
				_ = yym1241
				if false {
				} else if z.HasExtensions() && z.EncExt(yy1240) {
				} else {
					z.EncFallback(yy1240)
				}
			}
			if yyr1236 || yy2arr1236 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1236[1] {
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1243 := z.EncBinary()
						_ = yym1243
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1236[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ingress"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ingress == nil {
						r.EncodeNil()
					} else {
						yym1244 := z.EncBinary()
						_ = yym1244
						if false {
						} else {
							h.encSliceNetworkPolicyIngressRule(([]NetworkPolicyIngressRule)(x.Ingress), e)
						}
					}
				}
			}
			if yyr1236 || yy2arr1236 {
				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
	yym1245 := z.DecBinary()
	_ = yym1245
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1246 := r.ContainerType()
		if yyct1246 == codecSelferValueTypeMap1234 {
			yyl1246 := r.ReadMapStart()
			if yyl1246 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1246, d)
			}
		} else if yyct1246 == codecSelferValueTypeArray1234 {
			yyl1246 := r.ReadArrayStart()
			if yyl1246 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1246, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicySpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1247Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1247Slc
	var yyhl1247 bool = l >= 0
	for yyj1247 := 0; ; yyj1247++ {
		if yyhl1247 {
			if yyj1247 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1247Slc = r.DecodeBytes(yys1247Slc, true, true)
		yys1247 := string(yys1247Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1247 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				x.PodSelector = pkg1_unversioned.LabelSelector{}
			} else {
				yyv1248 := &x.PodSelector
				yym1249 := z.DecBinary()
				_ = yym1249
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1248) {
				} else {
					z.DecFallback(yyv1248, false)
				}
			}
		case "ingress":
			if r.TryDecodeAsNil() {
				x.Ingress = nil
			} else {
				yyv1250 := &x.Ingress
				yym1251 := z.DecBinary()
				_ = yym1251
				if false {
				} else {
					h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1250), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1247)
		} // end switch yys1247
	} // end for yyj1247
	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 yyj1252 int
	var yyb1252 bool
	var yyhl1252 bool = l >= 0
	yyj1252++
	if yyhl1252 {
		yyb1252 = yyj1252 > l
	} else {
		yyb1252 = r.CheckBreak()
	}
	if yyb1252 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.PodSelector = pkg1_unversioned.LabelSelector{}
	} else {
		yyv1253 := &x.PodSelector
		yym1254 := z.DecBinary()
		_ = yym1254
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1253) {
		} else {
			z.DecFallback(yyv1253, false)
		}
	}
	yyj1252++
	if yyhl1252 {
		yyb1252 = yyj1252 > l
	} else {
		yyb1252 = r.CheckBreak()
	}
	if yyb1252 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ingress = nil
	} else {
		yyv1255 := &x.Ingress
		yym1256 := z.DecBinary()
		_ = yym1256
		if false {
		} else {
			h.decSliceNetworkPolicyIngressRule((*[]NetworkPolicyIngressRule)(yyv1255), d)
		}
	}
	for {
		yyj1252++
		if yyhl1252 {
			yyb1252 = yyj1252 > l
		} else {
			yyb1252 = r.CheckBreak()
		}
		if yyb1252 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1252-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 {
		yym1257 := z.EncBinary()
		_ = yym1257
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1258 := !z.EncBinary()
			yy2arr1258 := z.EncBasicHandle().StructToArray
			var yyq1258 [2]bool
			_, _, _ = yysep1258, yyq1258, yy2arr1258
			const yyr1258 bool = false
			yyq1258[0] = len(x.Ports) != 0
			yyq1258[1] = len(x.From) != 0
			var yynn1258 int
			if yyr1258 || yy2arr1258 {
				r.EncodeArrayStart(2)
			} else {
				yynn1258 = 0
				for _, b := range yyq1258 {
					if b {
						yynn1258++
					}
				}
				r.EncodeMapStart(yynn1258)
				yynn1258 = 0
			}
			if yyr1258 || yy2arr1258 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1258[0] {
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1260 := z.EncBinary()
						_ = yym1260
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1258[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("ports"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Ports == nil {
						r.EncodeNil()
					} else {
						yym1261 := z.EncBinary()
						_ = yym1261
						if false {
						} else {
							h.encSliceNetworkPolicyPort(([]NetworkPolicyPort)(x.Ports), e)
						}
					}
				}
			}
			if yyr1258 || yy2arr1258 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1258[1] {
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1263 := z.EncBinary()
						_ = yym1263
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1258[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("from"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.From == nil {
						r.EncodeNil()
					} else {
						yym1264 := z.EncBinary()
						_ = yym1264
						if false {
						} else {
							h.encSliceNetworkPolicyPeer(([]NetworkPolicyPeer)(x.From), e)
						}
					}
				}
			}
			if yyr1258 || yy2arr1258 {
				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
	yym1265 := z.DecBinary()
	_ = yym1265
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1266 := r.ContainerType()
		if yyct1266 == codecSelferValueTypeMap1234 {
			yyl1266 := r.ReadMapStart()
			if yyl1266 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1266, d)
			}
		} else if yyct1266 == codecSelferValueTypeArray1234 {
			yyl1266 := r.ReadArrayStart()
			if yyl1266 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1266, 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 yys1267Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1267Slc
	var yyhl1267 bool = l >= 0
	for yyj1267 := 0; ; yyj1267++ {
		if yyhl1267 {
			if yyj1267 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1267Slc = r.DecodeBytes(yys1267Slc, true, true)
		yys1267 := string(yys1267Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1267 {
		case "ports":
			if r.TryDecodeAsNil() {
				x.Ports = nil
			} else {
				yyv1268 := &x.Ports
				yym1269 := z.DecBinary()
				_ = yym1269
				if false {
				} else {
					h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1268), d)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv1270 := &x.From
				yym1271 := z.DecBinary()
				_ = yym1271
				if false {
				} else {
					h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1270), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1267)
		} // end switch yys1267
	} // end for yyj1267
	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 yyj1272 int
	var yyb1272 bool
	var yyhl1272 bool = l >= 0
	yyj1272++
	if yyhl1272 {
		yyb1272 = yyj1272 > l
	} else {
		yyb1272 = r.CheckBreak()
	}
	if yyb1272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Ports = nil
	} else {
		yyv1273 := &x.Ports
		yym1274 := z.DecBinary()
		_ = yym1274
		if false {
		} else {
			h.decSliceNetworkPolicyPort((*[]NetworkPolicyPort)(yyv1273), d)
		}
	}
	yyj1272++
	if yyhl1272 {
		yyb1272 = yyj1272 > l
	} else {
		yyb1272 = r.CheckBreak()
	}
	if yyb1272 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv1275 := &x.From
		yym1276 := z.DecBinary()
		_ = yym1276
		if false {
		} else {
			h.decSliceNetworkPolicyPeer((*[]NetworkPolicyPeer)(yyv1275), d)
		}
	}
	for {
		yyj1272++
		if yyhl1272 {
			yyb1272 = yyj1272 > l
		} else {
			yyb1272 = r.CheckBreak()
		}
		if yyb1272 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1272-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 {
		yym1277 := z.EncBinary()
		_ = yym1277
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1278 := !z.EncBinary()
			yy2arr1278 := z.EncBasicHandle().StructToArray
			var yyq1278 [2]bool
			_, _, _ = yysep1278, yyq1278, yy2arr1278
			const yyr1278 bool = false
			yyq1278[0] = x.Protocol != nil
			yyq1278[1] = x.Port != nil
			var yynn1278 int
			if yyr1278 || yy2arr1278 {
				r.EncodeArrayStart(2)
			} else {
				yynn1278 = 0
				for _, b := range yyq1278 {
					if b {
						yynn1278++
					}
				}
				r.EncodeMapStart(yynn1278)
				yynn1278 = 0
			}
			if yyr1278 || yy2arr1278 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1278[0] {
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1280 := *x.Protocol
						yym1281 := z.EncBinary()
						_ = yym1281
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1280) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1280))
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1278[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("protocol"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Protocol == nil {
						r.EncodeNil()
					} else {
						yy1282 := *x.Protocol
						yym1283 := z.EncBinary()
						_ = yym1283
						if false {
						} else if z.HasExtensions() && z.EncExt(yy1282) {
						} else {
							r.EncodeString(codecSelferC_UTF81234, string(yy1282))
						}
					}
				}
			}
			if yyr1278 || yy2arr1278 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1278[1] {
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1285 := z.EncBinary()
						_ = yym1285
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1285 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1278[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("port"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Port == nil {
						r.EncodeNil()
					} else {
						yym1286 := z.EncBinary()
						_ = yym1286
						if false {
						} else if z.HasExtensions() && z.EncExt(x.Port) {
						} else if !yym1286 && z.IsJSONHandle() {
							z.EncJSONMarshal(x.Port)
						} else {
							z.EncFallback(x.Port)
						}
					}
				}
			}
			if yyr1278 || yy2arr1278 {
				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
	yym1287 := z.DecBinary()
	_ = yym1287
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1288 := r.ContainerType()
		if yyct1288 == codecSelferValueTypeMap1234 {
			yyl1288 := r.ReadMapStart()
			if yyl1288 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1288, d)
			}
		} else if yyct1288 == codecSelferValueTypeArray1234 {
			yyl1288 := r.ReadArrayStart()
			if yyl1288 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1288, 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 yys1289Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1289Slc
	var yyhl1289 bool = l >= 0
	for yyj1289 := 0; ; yyj1289++ {
		if yyhl1289 {
			if yyj1289 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1289Slc = r.DecodeBytes(yys1289Slc, true, true)
		yys1289 := string(yys1289Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1289 {
		case "protocol":
			if r.TryDecodeAsNil() {
				if x.Protocol != nil {
					x.Protocol = nil
				}
			} else {
				if x.Protocol == nil {
					x.Protocol = new(pkg2_api.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)
				}
				yym1292 := z.DecBinary()
				_ = yym1292
				if false {
				} else if z.HasExtensions() && z.DecExt(x.Port) {
				} else if !yym1292 && z.IsJSONHandle() {
					z.DecJSONUnmarshal(x.Port)
				} else {
					z.DecFallback(x.Port, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1289)
		} // end switch yys1289
	} // end for yyj1289
	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 yyj1293 int
	var yyb1293 bool
	var yyhl1293 bool = l >= 0
	yyj1293++
	if yyhl1293 {
		yyb1293 = yyj1293 > l
	} else {
		yyb1293 = r.CheckBreak()
	}
	if yyb1293 {
		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_api.Protocol)
		}
		x.Protocol.CodecDecodeSelf(d)
	}
	yyj1293++
	if yyhl1293 {
		yyb1293 = yyj1293 > l
	} else {
		yyb1293 = r.CheckBreak()
	}
	if yyb1293 {
		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)
		}
		yym1296 := z.DecBinary()
		_ = yym1296
		if false {
		} else if z.HasExtensions() && z.DecExt(x.Port) {
		} else if !yym1296 && z.IsJSONHandle() {
			z.DecJSONUnmarshal(x.Port)
		} else {
			z.DecFallback(x.Port, false)
		}
	}
	for {
		yyj1293++
		if yyhl1293 {
			yyb1293 = yyj1293 > l
		} else {
			yyb1293 = r.CheckBreak()
		}
		if yyb1293 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1293-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 {
		yym1297 := z.EncBinary()
		_ = yym1297
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1298 := !z.EncBinary()
			yy2arr1298 := z.EncBasicHandle().StructToArray
			var yyq1298 [2]bool
			_, _, _ = yysep1298, yyq1298, yy2arr1298
			const yyr1298 bool = false
			yyq1298[0] = x.PodSelector != nil
			yyq1298[1] = x.NamespaceSelector != nil
			var yynn1298 int
			if yyr1298 || yy2arr1298 {
				r.EncodeArrayStart(2)
			} else {
				yynn1298 = 0
				for _, b := range yyq1298 {
					if b {
						yynn1298++
					}
				}
				r.EncodeMapStart(yynn1298)
				yynn1298 = 0
			}
			if yyr1298 || yy2arr1298 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1298[0] {
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						yym1300 := z.EncBinary()
						_ = yym1300
						if false {
						} else if z.HasExtensions() && z.EncExt(x.PodSelector) {
						} else {
							z.EncFallback(x.PodSelector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1298[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("podSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.PodSelector == nil {
						r.EncodeNil()
					} else {
						yym1301 := z.EncBinary()
						_ = yym1301
						if false {
						} else if z.HasExtensions() && z.EncExt(x.PodSelector) {
						} else {
							z.EncFallback(x.PodSelector)
						}
					}
				}
			}
			if yyr1298 || yy2arr1298 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1298[1] {
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						yym1303 := z.EncBinary()
						_ = yym1303
						if false {
						} else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
						} else {
							z.EncFallback(x.NamespaceSelector)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1298[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("namespaceSelector"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.NamespaceSelector == nil {
						r.EncodeNil()
					} else {
						yym1304 := z.EncBinary()
						_ = yym1304
						if false {
						} else if z.HasExtensions() && z.EncExt(x.NamespaceSelector) {
						} else {
							z.EncFallback(x.NamespaceSelector)
						}
					}
				}
			}
			if yyr1298 || yy2arr1298 {
				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
	yym1305 := z.DecBinary()
	_ = yym1305
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1306 := r.ContainerType()
		if yyct1306 == codecSelferValueTypeMap1234 {
			yyl1306 := r.ReadMapStart()
			if yyl1306 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1306, d)
			}
		} else if yyct1306 == codecSelferValueTypeArray1234 {
			yyl1306 := r.ReadArrayStart()
			if yyl1306 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1306, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NetworkPolicyPeer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys1307Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1307Slc
	var yyhl1307 bool = l >= 0
	for yyj1307 := 0; ; yyj1307++ {
		if yyhl1307 {
			if yyj1307 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1307Slc = r.DecodeBytes(yys1307Slc, true, true)
		yys1307 := string(yys1307Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1307 {
		case "podSelector":
			if r.TryDecodeAsNil() {
				if x.PodSelector != nil {
					x.PodSelector = nil
				}
			} else {
				if x.PodSelector == nil {
					x.PodSelector = new(pkg1_unversioned.LabelSelector)
				}
				yym1309 := z.DecBinary()
				_ = yym1309
				if false {
				} else if z.HasExtensions() && z.DecExt(x.PodSelector) {
				} else {
					z.DecFallback(x.PodSelector, false)
				}
			}
		case "namespaceSelector":
			if r.TryDecodeAsNil() {
				if x.NamespaceSelector != nil {
					x.NamespaceSelector = nil
				}
			} else {
				if x.NamespaceSelector == nil {
					x.NamespaceSelector = new(pkg1_unversioned.LabelSelector)
				}
				yym1311 := z.DecBinary()
				_ = yym1311
				if false {
				} else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
				} else {
					z.DecFallback(x.NamespaceSelector, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1307)
		} // end switch yys1307
	} // end for yyj1307
	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 yyj1312 int
	var yyb1312 bool
	var yyhl1312 bool = l >= 0
	yyj1312++
	if yyhl1312 {
		yyb1312 = yyj1312 > l
	} else {
		yyb1312 = r.CheckBreak()
	}
	if yyb1312 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym1314 := z.DecBinary()
		_ = yym1314
		if false {
		} else if z.HasExtensions() && z.DecExt(x.PodSelector) {
		} else {
			z.DecFallback(x.PodSelector, false)
		}
	}
	yyj1312++
	if yyhl1312 {
		yyb1312 = yyj1312 > l
	} else {
		yyb1312 = r.CheckBreak()
	}
	if yyb1312 {
		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(pkg1_unversioned.LabelSelector)
		}
		yym1316 := z.DecBinary()
		_ = yym1316
		if false {
		} else if z.HasExtensions() && z.DecExt(x.NamespaceSelector) {
		} else {
			z.DecFallback(x.NamespaceSelector, false)
		}
	}
	for {
		yyj1312++
		if yyhl1312 {
			yyb1312 = yyj1312 > l
		} else {
			yyb1312 = r.CheckBreak()
		}
		if yyb1312 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1312-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 {
		yym1317 := z.EncBinary()
		_ = yym1317
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep1318 := !z.EncBinary()
			yy2arr1318 := z.EncBasicHandle().StructToArray
			var yyq1318 [4]bool
			_, _, _ = yysep1318, yyq1318, yy2arr1318
			const yyr1318 bool = false
			yyq1318[0] = x.Kind != ""
			yyq1318[1] = x.APIVersion != ""
			yyq1318[2] = true
			var yynn1318 int
			if yyr1318 || yy2arr1318 {
				r.EncodeArrayStart(4)
			} else {
				yynn1318 = 1
				for _, b := range yyq1318 {
					if b {
						yynn1318++
					}
				}
				r.EncodeMapStart(yynn1318)
				yynn1318 = 0
			}
			if yyr1318 || yy2arr1318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1318[0] {
					yym1320 := z.EncBinary()
					_ = yym1320
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1318[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1321 := z.EncBinary()
					_ = yym1321
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr1318 || yy2arr1318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1318[1] {
					yym1323 := z.EncBinary()
					_ = yym1323
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq1318[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym1324 := z.EncBinary()
					_ = yym1324
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr1318 || yy2arr1318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq1318[2] {
					yy1326 := &x.ListMeta
					yym1327 := z.EncBinary()
					_ = yym1327
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1326) {
					} else {
						z.EncFallback(yy1326)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq1318[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("metadata"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy1328 := &x.ListMeta
					yym1329 := z.EncBinary()
					_ = yym1329
					if false {
					} else if z.HasExtensions() && z.EncExt(yy1328) {
					} else {
						z.EncFallback(yy1328)
					}
				}
			}
			if yyr1318 || yy2arr1318 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if x.Items == nil {
					r.EncodeNil()
				} else {
					yym1331 := z.EncBinary()
					_ = yym1331
					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 {
					yym1332 := z.EncBinary()
					_ = yym1332
					if false {
					} else {
						h.encSliceNetworkPolicy(([]NetworkPolicy)(x.Items), e)
					}
				}
			}
			if yyr1318 || yy2arr1318 {
				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
	yym1333 := z.DecBinary()
	_ = yym1333
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct1334 := r.ContainerType()
		if yyct1334 == codecSelferValueTypeMap1234 {
			yyl1334 := r.ReadMapStart()
			if yyl1334 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl1334, d)
			}
		} else if yyct1334 == codecSelferValueTypeArray1234 {
			yyl1334 := r.ReadArrayStart()
			if yyl1334 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl1334, 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 yys1335Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys1335Slc
	var yyhl1335 bool = l >= 0
	for yyj1335 := 0; ; yyj1335++ {
		if yyhl1335 {
			if yyj1335 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys1335Slc = r.DecodeBytes(yys1335Slc, true, true)
		yys1335 := string(yys1335Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys1335 {
		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 {
				yyv1338 := &x.ListMeta
				yym1339 := z.DecBinary()
				_ = yym1339
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv1338) {
				} else {
					z.DecFallback(yyv1338, false)
				}
			}
		case "items":
			if r.TryDecodeAsNil() {
				x.Items = nil
			} else {
				yyv1340 := &x.Items
				yym1341 := z.DecBinary()
				_ = yym1341
				if false {
				} else {
					h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1340), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys1335)
		} // end switch yys1335
	} // end for yyj1335
	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 yyj1342 int
	var yyb1342 bool
	var yyhl1342 bool = l >= 0
	yyj1342++
	if yyhl1342 {
		yyb1342 = yyj1342 > l
	} else {
		yyb1342 = r.CheckBreak()
	}
	if yyb1342 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj1342++
	if yyhl1342 {
		yyb1342 = yyj1342 > l
	} else {
		yyb1342 = r.CheckBreak()
	}
	if yyb1342 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj1342++
	if yyhl1342 {
		yyb1342 = yyj1342 > l
	} else {
		yyb1342 = r.CheckBreak()
	}
	if yyb1342 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.ListMeta = pkg1_unversioned.ListMeta{}
	} else {
		yyv1345 := &x.ListMeta
		yym1346 := z.DecBinary()
		_ = yym1346
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv1345) {
		} else {
			z.DecFallback(yyv1345, false)
		}
	}
	yyj1342++
	if yyhl1342 {
		yyb1342 = yyj1342 > l
	} else {
		yyb1342 = r.CheckBreak()
	}
	if yyb1342 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Items = nil
	} else {
		yyv1347 := &x.Items
		yym1348 := z.DecBinary()
		_ = yym1348
		if false {
		} else {
			h.decSliceNetworkPolicy((*[]NetworkPolicy)(yyv1347), d)
		}
	}
	for {
		yyj1342++
		if yyhl1342 {
			yyb1342 = yyj1342 > l
		} else {
			yyb1342 = r.CheckBreak()
		}
		if yyb1342 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj1342-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 _, yyv1349 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem1234)
		yy1350 := &yyv1349
		yy1350.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

	yyv1351 := *v
	yyh1351, yyl1351 := z.DecSliceHelperStart()
	var yyc1351 bool
	if yyl1351 == 0 {
		if yyv1351 == nil {
			yyv1351 = []CustomMetricTarget{}
			yyc1351 = true
		} else if len(yyv1351) != 0 {
			yyv1351 = yyv1351[:0]
			yyc1351 = true
		}
	} else if yyl1351 > 0 {
		var yyrr1351, yyrl1351 int
		var yyrt1351 bool
		if yyl1351 > cap(yyv1351) {

			yyrg1351 := len(yyv1351) > 0
			yyv21351 := yyv1351
			yyrl1351, yyrt1351 = z.DecInferLen(yyl1351, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1351 {
				if yyrl1351 <= cap(yyv1351) {
					yyv1351 = yyv1351[:yyrl1351]
				} else {
					yyv1351 = make([]CustomMetricTarget, yyrl1351)
				}
			} else {
				yyv1351 = make([]CustomMetricTarget, yyrl1351)
			}
			yyc1351 = true
			yyrr1351 = len(yyv1351)
			if yyrg1351 {
				copy(yyv1351, yyv21351)
			}
		} else if yyl1351 != len(yyv1351) {
			yyv1351 = yyv1351[:yyl1351]
			yyc1351 = true
		}
		yyj1351 := 0
		for ; yyj1351 < yyrr1351; yyj1351++ {
			yyh1351.ElemContainerState(yyj1351)
			if r.TryDecodeAsNil() {
				yyv1351[yyj1351] = CustomMetricTarget{}
			} else {
				yyv1352 := &yyv1351[yyj1351]
				yyv1352.CodecDecodeSelf(d)
			}

		}
		if yyrt1351 {
			for ; yyj1351 < yyl1351; yyj1351++ {
				yyv1351 = append(yyv1351, CustomMetricTarget{})
				yyh1351.ElemContainerState(yyj1351)
				if r.TryDecodeAsNil() {
					yyv1351[yyj1351] = CustomMetricTarget{}
				} else {
					yyv1353 := &yyv1351[yyj1351]
					yyv1353.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1351 >= len(yyv1351) {
				yyv1351 = append(yyv1351, CustomMetricTarget{}) // var yyz1351 CustomMetricTarget
				yyc1351 = true
			}
			yyh1351.ElemContainerState(yyj1351)
			if yyj1351 < len(yyv1351) {
				if r.TryDecodeAsNil() {
					yyv1351[yyj1351] = CustomMetricTarget{}
				} else {
					yyv1354 := &yyv1351[yyj1351]
					yyv1354.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1351 < len(yyv1351) {
			yyv1351 = yyv1351[:yyj1351]
			yyc1351 = true
		} else if yyj1351 == 0 && yyv1351 == nil {
			yyv1351 = []CustomMetricTarget{}
			yyc1351 = true
		}
	}
	yyh1351.End()
	if yyc1351 {
		*v = yyv1351
	}
}

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

	yyv1357 := *v
	yyh1357, yyl1357 := z.DecSliceHelperStart()
	var yyc1357 bool
	if yyl1357 == 0 {
		if yyv1357 == nil {
			yyv1357 = []CustomMetricCurrentStatus{}
			yyc1357 = true
		} else if len(yyv1357) != 0 {
			yyv1357 = yyv1357[:0]
			yyc1357 = true
		}
	} else if yyl1357 > 0 {
		var yyrr1357, yyrl1357 int
		var yyrt1357 bool
		if yyl1357 > cap(yyv1357) {

			yyrg1357 := len(yyv1357) > 0
			yyv21357 := yyv1357
			yyrl1357, yyrt1357 = z.DecInferLen(yyl1357, z.DecBasicHandle().MaxInitLen, 72)
			if yyrt1357 {
				if yyrl1357 <= cap(yyv1357) {
					yyv1357 = yyv1357[:yyrl1357]
				} else {
					yyv1357 = make([]CustomMetricCurrentStatus, yyrl1357)
				}
			} else {
				yyv1357 = make([]CustomMetricCurrentStatus, yyrl1357)
			}
			yyc1357 = true
			yyrr1357 = len(yyv1357)
			if yyrg1357 {
				copy(yyv1357, yyv21357)
			}
		} else if yyl1357 != len(yyv1357) {
			yyv1357 = yyv1357[:yyl1357]
			yyc1357 = true
		}
		yyj1357 := 0
		for ; yyj1357 < yyrr1357; yyj1357++ {
			yyh1357.ElemContainerState(yyj1357)
			if r.TryDecodeAsNil() {
				yyv1357[yyj1357] = CustomMetricCurrentStatus{}
			} else {
				yyv1358 := &yyv1357[yyj1357]
				yyv1358.CodecDecodeSelf(d)
			}

		}
		if yyrt1357 {
			for ; yyj1357 < yyl1357; yyj1357++ {
				yyv1357 = append(yyv1357, CustomMetricCurrentStatus{})
				yyh1357.ElemContainerState(yyj1357)
				if r.TryDecodeAsNil() {
					yyv1357[yyj1357] = CustomMetricCurrentStatus{}
				} else {
					yyv1359 := &yyv1357[yyj1357]
					yyv1359.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1357 >= len(yyv1357) {
				yyv1357 = append(yyv1357, CustomMetricCurrentStatus{}) // var yyz1357 CustomMetricCurrentStatus
				yyc1357 = true
			}
			yyh1357.ElemContainerState(yyj1357)
			if yyj1357 < len(yyv1357) {
				if r.TryDecodeAsNil() {
					yyv1357[yyj1357] = CustomMetricCurrentStatus{}
				} else {
					yyv1360 := &yyv1357[yyj1357]
					yyv1360.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1357 < len(yyv1357) {
			yyv1357 = yyv1357[:yyj1357]
			yyc1357 = true
		} else if yyj1357 == 0 && yyv1357 == nil {
			yyv1357 = []CustomMetricCurrentStatus{}
			yyc1357 = true
		}
	}
	yyh1357.End()
	if yyc1357 {
		*v = yyv1357
	}
}

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

	yyv1363 := *v
	yyh1363, yyl1363 := z.DecSliceHelperStart()
	var yyc1363 bool
	if yyl1363 == 0 {
		if yyv1363 == nil {
			yyv1363 = []APIVersion{}
			yyc1363 = true
		} else if len(yyv1363) != 0 {
			yyv1363 = yyv1363[:0]
			yyc1363 = true
		}
	} else if yyl1363 > 0 {
		var yyrr1363, yyrl1363 int
		var yyrt1363 bool
		if yyl1363 > cap(yyv1363) {

			yyrg1363 := len(yyv1363) > 0
			yyv21363 := yyv1363
			yyrl1363, yyrt1363 = z.DecInferLen(yyl1363, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1363 {
				if yyrl1363 <= cap(yyv1363) {
					yyv1363 = yyv1363[:yyrl1363]
				} else {
					yyv1363 = make([]APIVersion, yyrl1363)
				}
			} else {
				yyv1363 = make([]APIVersion, yyrl1363)
			}
			yyc1363 = true
			yyrr1363 = len(yyv1363)
			if yyrg1363 {
				copy(yyv1363, yyv21363)
			}
		} else if yyl1363 != len(yyv1363) {
			yyv1363 = yyv1363[:yyl1363]
			yyc1363 = true
		}
		yyj1363 := 0
		for ; yyj1363 < yyrr1363; yyj1363++ {
			yyh1363.ElemContainerState(yyj1363)
			if r.TryDecodeAsNil() {
				yyv1363[yyj1363] = APIVersion{}
			} else {
				yyv1364 := &yyv1363[yyj1363]
				yyv1364.CodecDecodeSelf(d)
			}

		}
		if yyrt1363 {
			for ; yyj1363 < yyl1363; yyj1363++ {
				yyv1363 = append(yyv1363, APIVersion{})
				yyh1363.ElemContainerState(yyj1363)
				if r.TryDecodeAsNil() {
					yyv1363[yyj1363] = APIVersion{}
				} else {
					yyv1365 := &yyv1363[yyj1363]
					yyv1365.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1363 >= len(yyv1363) {
				yyv1363 = append(yyv1363, APIVersion{}) // var yyz1363 APIVersion
				yyc1363 = true
			}
			yyh1363.ElemContainerState(yyj1363)
			if yyj1363 < len(yyv1363) {
				if r.TryDecodeAsNil() {
					yyv1363[yyj1363] = APIVersion{}
				} else {
					yyv1366 := &yyv1363[yyj1363]
					yyv1366.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1363 < len(yyv1363) {
			yyv1363 = yyv1363[:yyj1363]
			yyc1363 = true
		} else if yyj1363 == 0 && yyv1363 == nil {
			yyv1363 = []APIVersion{}
			yyc1363 = true
		}
	}
	yyh1363.End()
	if yyc1363 {
		*v = yyv1363
	}
}

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

	yyv1369 := *v
	yyh1369, yyl1369 := z.DecSliceHelperStart()
	var yyc1369 bool
	if yyl1369 == 0 {
		if yyv1369 == nil {
			yyv1369 = []ThirdPartyResource{}
			yyc1369 = true
		} else if len(yyv1369) != 0 {
			yyv1369 = yyv1369[:0]
			yyc1369 = true
		}
	} else if yyl1369 > 0 {
		var yyrr1369, yyrl1369 int
		var yyrt1369 bool
		if yyl1369 > cap(yyv1369) {

			yyrg1369 := len(yyv1369) > 0
			yyv21369 := yyv1369
			yyrl1369, yyrt1369 = z.DecInferLen(yyl1369, z.DecBasicHandle().MaxInitLen, 296)
			if yyrt1369 {
				if yyrl1369 <= cap(yyv1369) {
					yyv1369 = yyv1369[:yyrl1369]
				} else {
					yyv1369 = make([]ThirdPartyResource, yyrl1369)
				}
			} else {
				yyv1369 = make([]ThirdPartyResource, yyrl1369)
			}
			yyc1369 = true
			yyrr1369 = len(yyv1369)
			if yyrg1369 {
				copy(yyv1369, yyv21369)
			}
		} else if yyl1369 != len(yyv1369) {
			yyv1369 = yyv1369[:yyl1369]
			yyc1369 = true
		}
		yyj1369 := 0
		for ; yyj1369 < yyrr1369; yyj1369++ {
			yyh1369.ElemContainerState(yyj1369)
			if r.TryDecodeAsNil() {
				yyv1369[yyj1369] = ThirdPartyResource{}
			} else {
				yyv1370 := &yyv1369[yyj1369]
				yyv1370.CodecDecodeSelf(d)
			}

		}
		if yyrt1369 {
			for ; yyj1369 < yyl1369; yyj1369++ {
				yyv1369 = append(yyv1369, ThirdPartyResource{})
				yyh1369.ElemContainerState(yyj1369)
				if r.TryDecodeAsNil() {
					yyv1369[yyj1369] = ThirdPartyResource{}
				} else {
					yyv1371 := &yyv1369[yyj1369]
					yyv1371.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1369 >= len(yyv1369) {
				yyv1369 = append(yyv1369, ThirdPartyResource{}) // var yyz1369 ThirdPartyResource
				yyc1369 = true
			}
			yyh1369.ElemContainerState(yyj1369)
			if yyj1369 < len(yyv1369) {
				if r.TryDecodeAsNil() {
					yyv1369[yyj1369] = ThirdPartyResource{}
				} else {
					yyv1372 := &yyv1369[yyj1369]
					yyv1372.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1369 < len(yyv1369) {
			yyv1369 = yyv1369[:yyj1369]
			yyc1369 = true
		} else if yyj1369 == 0 && yyv1369 == nil {
			yyv1369 = []ThirdPartyResource{}
			yyc1369 = true
		}
	}
	yyh1369.End()
	if yyc1369 {
		*v = yyv1369
	}
}

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

	yyv1375 := *v
	yyh1375, yyl1375 := z.DecSliceHelperStart()
	var yyc1375 bool
	if yyl1375 == 0 {
		if yyv1375 == nil {
			yyv1375 = []Deployment{}
			yyc1375 = true
		} else if len(yyv1375) != 0 {
			yyv1375 = yyv1375[:0]
			yyc1375 = true
		}
	} else if yyl1375 > 0 {
		var yyrr1375, yyrl1375 int
		var yyrt1375 bool
		if yyl1375 > cap(yyv1375) {

			yyrg1375 := len(yyv1375) > 0
			yyv21375 := yyv1375
			yyrl1375, yyrt1375 = z.DecInferLen(yyl1375, z.DecBasicHandle().MaxInitLen, 800)
			if yyrt1375 {
				if yyrl1375 <= cap(yyv1375) {
					yyv1375 = yyv1375[:yyrl1375]
				} else {
					yyv1375 = make([]Deployment, yyrl1375)
				}
			} else {
				yyv1375 = make([]Deployment, yyrl1375)
			}
			yyc1375 = true
			yyrr1375 = len(yyv1375)
			if yyrg1375 {
				copy(yyv1375, yyv21375)
			}
		} else if yyl1375 != len(yyv1375) {
			yyv1375 = yyv1375[:yyl1375]
			yyc1375 = true
		}
		yyj1375 := 0
		for ; yyj1375 < yyrr1375; yyj1375++ {
			yyh1375.ElemContainerState(yyj1375)
			if r.TryDecodeAsNil() {
				yyv1375[yyj1375] = Deployment{}
			} else {
				yyv1376 := &yyv1375[yyj1375]
				yyv1376.CodecDecodeSelf(d)
			}

		}
		if yyrt1375 {
			for ; yyj1375 < yyl1375; yyj1375++ {
				yyv1375 = append(yyv1375, Deployment{})
				yyh1375.ElemContainerState(yyj1375)
				if r.TryDecodeAsNil() {
					yyv1375[yyj1375] = Deployment{}
				} else {
					yyv1377 := &yyv1375[yyj1375]
					yyv1377.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1375 >= len(yyv1375) {
				yyv1375 = append(yyv1375, Deployment{}) // var yyz1375 Deployment
				yyc1375 = true
			}
			yyh1375.ElemContainerState(yyj1375)
			if yyj1375 < len(yyv1375) {
				if r.TryDecodeAsNil() {
					yyv1375[yyj1375] = Deployment{}
				} else {
					yyv1378 := &yyv1375[yyj1375]
					yyv1378.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1375 < len(yyv1375) {
			yyv1375 = yyv1375[:yyj1375]
			yyc1375 = true
		} else if yyj1375 == 0 && yyv1375 == nil {
			yyv1375 = []Deployment{}
			yyc1375 = true
		}
	}
	yyh1375.End()
	if yyc1375 {
		*v = yyv1375
	}
}

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

	yyv1381 := *v
	yyh1381, yyl1381 := z.DecSliceHelperStart()
	var yyc1381 bool
	if yyl1381 == 0 {
		if yyv1381 == nil {
			yyv1381 = []DaemonSet{}
			yyc1381 = true
		} else if len(yyv1381) != 0 {
			yyv1381 = yyv1381[:0]
			yyc1381 = true
		}
	} else if yyl1381 > 0 {
		var yyrr1381, yyrl1381 int
		var yyrt1381 bool
		if yyl1381 > cap(yyv1381) {

			yyrg1381 := len(yyv1381) > 0
			yyv21381 := yyv1381
			yyrl1381, yyrt1381 = z.DecInferLen(yyl1381, z.DecBasicHandle().MaxInitLen, 728)
			if yyrt1381 {
				if yyrl1381 <= cap(yyv1381) {
					yyv1381 = yyv1381[:yyrl1381]
				} else {
					yyv1381 = make([]DaemonSet, yyrl1381)
				}
			} else {
				yyv1381 = make([]DaemonSet, yyrl1381)
			}
			yyc1381 = true
			yyrr1381 = len(yyv1381)
			if yyrg1381 {
				copy(yyv1381, yyv21381)
			}
		} else if yyl1381 != len(yyv1381) {
			yyv1381 = yyv1381[:yyl1381]
			yyc1381 = true
		}
		yyj1381 := 0
		for ; yyj1381 < yyrr1381; yyj1381++ {
			yyh1381.ElemContainerState(yyj1381)
			if r.TryDecodeAsNil() {
				yyv1381[yyj1381] = DaemonSet{}
			} else {
				yyv1382 := &yyv1381[yyj1381]
				yyv1382.CodecDecodeSelf(d)
			}

		}
		if yyrt1381 {
			for ; yyj1381 < yyl1381; yyj1381++ {
				yyv1381 = append(yyv1381, DaemonSet{})
				yyh1381.ElemContainerState(yyj1381)
				if r.TryDecodeAsNil() {
					yyv1381[yyj1381] = DaemonSet{}
				} else {
					yyv1383 := &yyv1381[yyj1381]
					yyv1383.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1381 >= len(yyv1381) {
				yyv1381 = append(yyv1381, DaemonSet{}) // var yyz1381 DaemonSet
				yyc1381 = true
			}
			yyh1381.ElemContainerState(yyj1381)
			if yyj1381 < len(yyv1381) {
				if r.TryDecodeAsNil() {
					yyv1381[yyj1381] = DaemonSet{}
				} else {
					yyv1384 := &yyv1381[yyj1381]
					yyv1384.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1381 < len(yyv1381) {
			yyv1381 = yyv1381[:yyj1381]
			yyc1381 = true
		} else if yyj1381 == 0 && yyv1381 == nil {
			yyv1381 = []DaemonSet{}
			yyc1381 = true
		}
	}
	yyh1381.End()
	if yyc1381 {
		*v = yyv1381
	}
}

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

	yyv1387 := *v
	yyh1387, yyl1387 := z.DecSliceHelperStart()
	var yyc1387 bool
	if yyl1387 == 0 {
		if yyv1387 == nil {
			yyv1387 = []ThirdPartyResourceData{}
			yyc1387 = true
		} else if len(yyv1387) != 0 {
			yyv1387 = yyv1387[:0]
			yyc1387 = true
		}
	} else if yyl1387 > 0 {
		var yyrr1387, yyrl1387 int
		var yyrt1387 bool
		if yyl1387 > cap(yyv1387) {

			yyrg1387 := len(yyv1387) > 0
			yyv21387 := yyv1387
			yyrl1387, yyrt1387 = z.DecInferLen(yyl1387, z.DecBasicHandle().MaxInitLen, 280)
			if yyrt1387 {
				if yyrl1387 <= cap(yyv1387) {
					yyv1387 = yyv1387[:yyrl1387]
				} else {
					yyv1387 = make([]ThirdPartyResourceData, yyrl1387)
				}
			} else {
				yyv1387 = make([]ThirdPartyResourceData, yyrl1387)
			}
			yyc1387 = true
			yyrr1387 = len(yyv1387)
			if yyrg1387 {
				copy(yyv1387, yyv21387)
			}
		} else if yyl1387 != len(yyv1387) {
			yyv1387 = yyv1387[:yyl1387]
			yyc1387 = true
		}
		yyj1387 := 0
		for ; yyj1387 < yyrr1387; yyj1387++ {
			yyh1387.ElemContainerState(yyj1387)
			if r.TryDecodeAsNil() {
				yyv1387[yyj1387] = ThirdPartyResourceData{}
			} else {
				yyv1388 := &yyv1387[yyj1387]
				yyv1388.CodecDecodeSelf(d)
			}

		}
		if yyrt1387 {
			for ; yyj1387 < yyl1387; yyj1387++ {
				yyv1387 = append(yyv1387, ThirdPartyResourceData{})
				yyh1387.ElemContainerState(yyj1387)
				if r.TryDecodeAsNil() {
					yyv1387[yyj1387] = ThirdPartyResourceData{}
				} else {
					yyv1389 := &yyv1387[yyj1387]
					yyv1389.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1387 >= len(yyv1387) {
				yyv1387 = append(yyv1387, ThirdPartyResourceData{}) // var yyz1387 ThirdPartyResourceData
				yyc1387 = true
			}
			yyh1387.ElemContainerState(yyj1387)
			if yyj1387 < len(yyv1387) {
				if r.TryDecodeAsNil() {
					yyv1387[yyj1387] = ThirdPartyResourceData{}
				} else {
					yyv1390 := &yyv1387[yyj1387]
					yyv1390.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1387 < len(yyv1387) {
			yyv1387 = yyv1387[:yyj1387]
			yyc1387 = true
		} else if yyj1387 == 0 && yyv1387 == nil {
			yyv1387 = []ThirdPartyResourceData{}
			yyc1387 = true
		}
	}
	yyh1387.End()
	if yyc1387 {
		*v = yyv1387
	}
}

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

	yyv1393 := *v
	yyh1393, yyl1393 := z.DecSliceHelperStart()
	var yyc1393 bool
	if yyl1393 == 0 {
		if yyv1393 == nil {
			yyv1393 = []Ingress{}
			yyc1393 = true
		} else if len(yyv1393) != 0 {
			yyv1393 = yyv1393[:0]
			yyc1393 = true
		}
	} else if yyl1393 > 0 {
		var yyrr1393, yyrl1393 int
		var yyrt1393 bool
		if yyl1393 > cap(yyv1393) {

			yyrg1393 := len(yyv1393) > 0
			yyv21393 := yyv1393
			yyrl1393, yyrt1393 = z.DecInferLen(yyl1393, z.DecBasicHandle().MaxInitLen, 336)
			if yyrt1393 {
				if yyrl1393 <= cap(yyv1393) {
					yyv1393 = yyv1393[:yyrl1393]
				} else {
					yyv1393 = make([]Ingress, yyrl1393)
				}
			} else {
				yyv1393 = make([]Ingress, yyrl1393)
			}
			yyc1393 = true
			yyrr1393 = len(yyv1393)
			if yyrg1393 {
				copy(yyv1393, yyv21393)
			}
		} else if yyl1393 != len(yyv1393) {
			yyv1393 = yyv1393[:yyl1393]
			yyc1393 = true
		}
		yyj1393 := 0
		for ; yyj1393 < yyrr1393; yyj1393++ {
			yyh1393.ElemContainerState(yyj1393)
			if r.TryDecodeAsNil() {
				yyv1393[yyj1393] = Ingress{}
			} else {
				yyv1394 := &yyv1393[yyj1393]
				yyv1394.CodecDecodeSelf(d)
			}

		}
		if yyrt1393 {
			for ; yyj1393 < yyl1393; yyj1393++ {
				yyv1393 = append(yyv1393, Ingress{})
				yyh1393.ElemContainerState(yyj1393)
				if r.TryDecodeAsNil() {
					yyv1393[yyj1393] = Ingress{}
				} else {
					yyv1395 := &yyv1393[yyj1393]
					yyv1395.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1393 >= len(yyv1393) {
				yyv1393 = append(yyv1393, Ingress{}) // var yyz1393 Ingress
				yyc1393 = true
			}
			yyh1393.ElemContainerState(yyj1393)
			if yyj1393 < len(yyv1393) {
				if r.TryDecodeAsNil() {
					yyv1393[yyj1393] = Ingress{}
				} else {
					yyv1396 := &yyv1393[yyj1393]
					yyv1396.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1393 < len(yyv1393) {
			yyv1393 = yyv1393[:yyj1393]
			yyc1393 = true
		} else if yyj1393 == 0 && yyv1393 == nil {
			yyv1393 = []Ingress{}
			yyc1393 = true
		}
	}
	yyh1393.End()
	if yyc1393 {
		*v = yyv1393
	}
}

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

	yyv1399 := *v
	yyh1399, yyl1399 := z.DecSliceHelperStart()
	var yyc1399 bool
	if yyl1399 == 0 {
		if yyv1399 == nil {
			yyv1399 = []IngressTLS{}
			yyc1399 = true
		} else if len(yyv1399) != 0 {
			yyv1399 = yyv1399[:0]
			yyc1399 = true
		}
	} else if yyl1399 > 0 {
		var yyrr1399, yyrl1399 int
		var yyrt1399 bool
		if yyl1399 > cap(yyv1399) {

			yyrg1399 := len(yyv1399) > 0
			yyv21399 := yyv1399
			yyrl1399, yyrt1399 = z.DecInferLen(yyl1399, z.DecBasicHandle().MaxInitLen, 40)
			if yyrt1399 {
				if yyrl1399 <= cap(yyv1399) {
					yyv1399 = yyv1399[:yyrl1399]
				} else {
					yyv1399 = make([]IngressTLS, yyrl1399)
				}
			} else {
				yyv1399 = make([]IngressTLS, yyrl1399)
			}
			yyc1399 = true
			yyrr1399 = len(yyv1399)
			if yyrg1399 {
				copy(yyv1399, yyv21399)
			}
		} else if yyl1399 != len(yyv1399) {
			yyv1399 = yyv1399[:yyl1399]
			yyc1399 = true
		}
		yyj1399 := 0
		for ; yyj1399 < yyrr1399; yyj1399++ {
			yyh1399.ElemContainerState(yyj1399)
			if r.TryDecodeAsNil() {
				yyv1399[yyj1399] = IngressTLS{}
			} else {
				yyv1400 := &yyv1399[yyj1399]
				yyv1400.CodecDecodeSelf(d)
			}

		}
		if yyrt1399 {
			for ; yyj1399 < yyl1399; yyj1399++ {
				yyv1399 = append(yyv1399, IngressTLS{})
				yyh1399.ElemContainerState(yyj1399)
				if r.TryDecodeAsNil() {
					yyv1399[yyj1399] = IngressTLS{}
				} else {
					yyv1401 := &yyv1399[yyj1399]
					yyv1401.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1399 >= len(yyv1399) {
				yyv1399 = append(yyv1399, IngressTLS{}) // var yyz1399 IngressTLS
				yyc1399 = true
			}
			yyh1399.ElemContainerState(yyj1399)
			if yyj1399 < len(yyv1399) {
				if r.TryDecodeAsNil() {
					yyv1399[yyj1399] = IngressTLS{}
				} else {
					yyv1402 := &yyv1399[yyj1399]
					yyv1402.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1399 < len(yyv1399) {
			yyv1399 = yyv1399[:yyj1399]
			yyc1399 = true
		} else if yyj1399 == 0 && yyv1399 == nil {
			yyv1399 = []IngressTLS{}
			yyc1399 = true
		}
	}
	yyh1399.End()
	if yyc1399 {
		*v = yyv1399
	}
}

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

	yyv1405 := *v
	yyh1405, yyl1405 := z.DecSliceHelperStart()
	var yyc1405 bool
	if yyl1405 == 0 {
		if yyv1405 == nil {
			yyv1405 = []IngressRule{}
			yyc1405 = true
		} else if len(yyv1405) != 0 {
			yyv1405 = yyv1405[:0]
			yyc1405 = true
		}
	} else if yyl1405 > 0 {
		var yyrr1405, yyrl1405 int
		var yyrt1405 bool
		if yyl1405 > cap(yyv1405) {

			yyrg1405 := len(yyv1405) > 0
			yyv21405 := yyv1405
			yyrl1405, yyrt1405 = z.DecInferLen(yyl1405, z.DecBasicHandle().MaxInitLen, 24)
			if yyrt1405 {
				if yyrl1405 <= cap(yyv1405) {
					yyv1405 = yyv1405[:yyrl1405]
				} else {
					yyv1405 = make([]IngressRule, yyrl1405)
				}
			} else {
				yyv1405 = make([]IngressRule, yyrl1405)
			}
			yyc1405 = true
			yyrr1405 = len(yyv1405)
			if yyrg1405 {
				copy(yyv1405, yyv21405)
			}
		} else if yyl1405 != len(yyv1405) {
			yyv1405 = yyv1405[:yyl1405]
			yyc1405 = true
		}
		yyj1405 := 0
		for ; yyj1405 < yyrr1405; yyj1405++ {
			yyh1405.ElemContainerState(yyj1405)
			if r.TryDecodeAsNil() {
				yyv1405[yyj1405] = IngressRule{}
			} else {
				yyv1406 := &yyv1405[yyj1405]
				yyv1406.CodecDecodeSelf(d)
			}

		}
		if yyrt1405 {
			for ; yyj1405 < yyl1405; yyj1405++ {
				yyv1405 = append(yyv1405, IngressRule{})
				yyh1405.ElemContainerState(yyj1405)
				if r.TryDecodeAsNil() {
					yyv1405[yyj1405] = IngressRule{}
				} else {
					yyv1407 := &yyv1405[yyj1405]
					yyv1407.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1405 >= len(yyv1405) {
				yyv1405 = append(yyv1405, IngressRule{}) // var yyz1405 IngressRule
				yyc1405 = true
			}
			yyh1405.ElemContainerState(yyj1405)
			if yyj1405 < len(yyv1405) {
				if r.TryDecodeAsNil() {
					yyv1405[yyj1405] = IngressRule{}
				} else {
					yyv1408 := &yyv1405[yyj1405]
					yyv1408.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1405 < len(yyv1405) {
			yyv1405 = yyv1405[:yyj1405]
			yyc1405 = true
		} else if yyj1405 == 0 && yyv1405 == nil {
			yyv1405 = []IngressRule{}
			yyc1405 = true
		}
	}
	yyh1405.End()
	if yyc1405 {
		*v = yyv1405
	}
}

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

	yyv1411 := *v
	yyh1411, yyl1411 := z.DecSliceHelperStart()
	var yyc1411 bool
	if yyl1411 == 0 {
		if yyv1411 == nil {
			yyv1411 = []HTTPIngressPath{}
			yyc1411 = true
		} else if len(yyv1411) != 0 {
			yyv1411 = yyv1411[:0]
			yyc1411 = true
		}
	} else if yyl1411 > 0 {
		var yyrr1411, yyrl1411 int
		var yyrt1411 bool
		if yyl1411 > cap(yyv1411) {

			yyrg1411 := len(yyv1411) > 0
			yyv21411 := yyv1411
			yyrl1411, yyrt1411 = z.DecInferLen(yyl1411, z.DecBasicHandle().MaxInitLen, 64)
			if yyrt1411 {
				if yyrl1411 <= cap(yyv1411) {
					yyv1411 = yyv1411[:yyrl1411]
				} else {
					yyv1411 = make([]HTTPIngressPath, yyrl1411)
				}
			} else {
				yyv1411 = make([]HTTPIngressPath, yyrl1411)
			}
			yyc1411 = true
			yyrr1411 = len(yyv1411)
			if yyrg1411 {
				copy(yyv1411, yyv21411)
			}
		} else if yyl1411 != len(yyv1411) {
			yyv1411 = yyv1411[:yyl1411]
			yyc1411 = true
		}
		yyj1411 := 0
		for ; yyj1411 < yyrr1411; yyj1411++ {
			yyh1411.ElemContainerState(yyj1411)
			if r.TryDecodeAsNil() {
				yyv1411[yyj1411] = HTTPIngressPath{}
			} else {
				yyv1412 := &yyv1411[yyj1411]
				yyv1412.CodecDecodeSelf(d)
			}

		}
		if yyrt1411 {
			for ; yyj1411 < yyl1411; yyj1411++ {
				yyv1411 = append(yyv1411, HTTPIngressPath{})
				yyh1411.ElemContainerState(yyj1411)
				if r.TryDecodeAsNil() {
					yyv1411[yyj1411] = HTTPIngressPath{}
				} else {
					yyv1413 := &yyv1411[yyj1411]
					yyv1413.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1411 >= len(yyv1411) {
				yyv1411 = append(yyv1411, HTTPIngressPath{}) // var yyz1411 HTTPIngressPath
				yyc1411 = true
			}
			yyh1411.ElemContainerState(yyj1411)
			if yyj1411 < len(yyv1411) {
				if r.TryDecodeAsNil() {
					yyv1411[yyj1411] = HTTPIngressPath{}
				} else {
					yyv1414 := &yyv1411[yyj1411]
					yyv1414.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1411 < len(yyv1411) {
			yyv1411 = yyv1411[:yyj1411]
			yyc1411 = true
		} else if yyj1411 == 0 && yyv1411 == nil {
			yyv1411 = []HTTPIngressPath{}
			yyc1411 = true
		}
	}
	yyh1411.End()
	if yyc1411 {
		*v = yyv1411
	}
}

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

	yyv1417 := *v
	yyh1417, yyl1417 := z.DecSliceHelperStart()
	var yyc1417 bool
	if yyl1417 == 0 {
		if yyv1417 == nil {
			yyv1417 = []ReplicaSet{}
			yyc1417 = true
		} else if len(yyv1417) != 0 {
			yyv1417 = yyv1417[:0]
			yyc1417 = true
		}
	} else if yyl1417 > 0 {
		var yyrr1417, yyrl1417 int
		var yyrt1417 bool
		if yyl1417 > cap(yyv1417) {

			yyrg1417 := len(yyv1417) > 0
			yyv21417 := yyv1417
			yyrl1417, yyrt1417 = z.DecInferLen(yyl1417, z.DecBasicHandle().MaxInitLen, 768)
			if yyrt1417 {
				if yyrl1417 <= cap(yyv1417) {
					yyv1417 = yyv1417[:yyrl1417]
				} else {
					yyv1417 = make([]ReplicaSet, yyrl1417)
				}
			} else {
				yyv1417 = make([]ReplicaSet, yyrl1417)
			}
			yyc1417 = true
			yyrr1417 = len(yyv1417)
			if yyrg1417 {
				copy(yyv1417, yyv21417)
			}
		} else if yyl1417 != len(yyv1417) {
			yyv1417 = yyv1417[:yyl1417]
			yyc1417 = true
		}
		yyj1417 := 0
		for ; yyj1417 < yyrr1417; yyj1417++ {
			yyh1417.ElemContainerState(yyj1417)
			if r.TryDecodeAsNil() {
				yyv1417[yyj1417] = ReplicaSet{}
			} else {
				yyv1418 := &yyv1417[yyj1417]
				yyv1418.CodecDecodeSelf(d)
			}

		}
		if yyrt1417 {
			for ; yyj1417 < yyl1417; yyj1417++ {
				yyv1417 = append(yyv1417, ReplicaSet{})
				yyh1417.ElemContainerState(yyj1417)
				if r.TryDecodeAsNil() {
					yyv1417[yyj1417] = ReplicaSet{}
				} else {
					yyv1419 := &yyv1417[yyj1417]
					yyv1419.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1417 >= len(yyv1417) {
				yyv1417 = append(yyv1417, ReplicaSet{}) // var yyz1417 ReplicaSet
				yyc1417 = true
			}
			yyh1417.ElemContainerState(yyj1417)
			if yyj1417 < len(yyv1417) {
				if r.TryDecodeAsNil() {
					yyv1417[yyj1417] = ReplicaSet{}
				} else {
					yyv1420 := &yyv1417[yyj1417]
					yyv1420.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1417 < len(yyv1417) {
			yyv1417 = yyv1417[:yyj1417]
			yyc1417 = true
		} else if yyj1417 == 0 && yyv1417 == nil {
			yyv1417 = []ReplicaSet{}
			yyc1417 = true
		}
	}
	yyh1417.End()
	if yyc1417 {
		*v = yyv1417
	}
}

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

	yyv1423 := *v
	yyh1423, yyl1423 := z.DecSliceHelperStart()
	var yyc1423 bool
	if yyl1423 == 0 {
		if yyv1423 == nil {
			yyv1423 = []ReplicaSetCondition{}
			yyc1423 = true
		} else if len(yyv1423) != 0 {
			yyv1423 = yyv1423[:0]
			yyc1423 = true
		}
	} else if yyl1423 > 0 {
		var yyrr1423, yyrl1423 int
		var yyrt1423 bool
		if yyl1423 > cap(yyv1423) {

			yyrg1423 := len(yyv1423) > 0
			yyv21423 := yyv1423
			yyrl1423, yyrt1423 = z.DecInferLen(yyl1423, z.DecBasicHandle().MaxInitLen, 88)
			if yyrt1423 {
				if yyrl1423 <= cap(yyv1423) {
					yyv1423 = yyv1423[:yyrl1423]
				} else {
					yyv1423 = make([]ReplicaSetCondition, yyrl1423)
				}
			} else {
				yyv1423 = make([]ReplicaSetCondition, yyrl1423)
			}
			yyc1423 = true
			yyrr1423 = len(yyv1423)
			if yyrg1423 {
				copy(yyv1423, yyv21423)
			}
		} else if yyl1423 != len(yyv1423) {
			yyv1423 = yyv1423[:yyl1423]
			yyc1423 = true
		}
		yyj1423 := 0
		for ; yyj1423 < yyrr1423; yyj1423++ {
			yyh1423.ElemContainerState(yyj1423)
			if r.TryDecodeAsNil() {
				yyv1423[yyj1423] = ReplicaSetCondition{}
			} else {
				yyv1424 := &yyv1423[yyj1423]
				yyv1424.CodecDecodeSelf(d)
			}

		}
		if yyrt1423 {
			for ; yyj1423 < yyl1423; yyj1423++ {
				yyv1423 = append(yyv1423, ReplicaSetCondition{})
				yyh1423.ElemContainerState(yyj1423)
				if r.TryDecodeAsNil() {
					yyv1423[yyj1423] = ReplicaSetCondition{}
				} else {
					yyv1425 := &yyv1423[yyj1423]
					yyv1425.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1423 >= len(yyv1423) {
				yyv1423 = append(yyv1423, ReplicaSetCondition{}) // var yyz1423 ReplicaSetCondition
				yyc1423 = true
			}
			yyh1423.ElemContainerState(yyj1423)
			if yyj1423 < len(yyv1423) {
				if r.TryDecodeAsNil() {
					yyv1423[yyj1423] = ReplicaSetCondition{}
				} else {
					yyv1426 := &yyv1423[yyj1423]
					yyv1426.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1423 < len(yyv1423) {
			yyv1423 = yyv1423[:yyj1423]
			yyc1423 = true
		} else if yyj1423 == 0 && yyv1423 == nil {
			yyv1423 = []ReplicaSetCondition{}
			yyc1423 = true
		}
	}
	yyh1423.End()
	if yyc1423 {
		*v = yyv1423
	}
}

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

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

	yyv1429 := *v
	yyh1429, yyl1429 := z.DecSliceHelperStart()
	var yyc1429 bool
	if yyl1429 == 0 {
		if yyv1429 == nil {
			yyv1429 = []pkg2_api.Capability{}
			yyc1429 = true
		} else if len(yyv1429) != 0 {
			yyv1429 = yyv1429[:0]
			yyc1429 = true
		}
	} else if yyl1429 > 0 {
		var yyrr1429, yyrl1429 int
		var yyrt1429 bool
		if yyl1429 > cap(yyv1429) {

			yyrl1429, yyrt1429 = z.DecInferLen(yyl1429, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1429 {
				if yyrl1429 <= cap(yyv1429) {
					yyv1429 = yyv1429[:yyrl1429]
				} else {
					yyv1429 = make([]pkg2_api.Capability, yyrl1429)
				}
			} else {
				yyv1429 = make([]pkg2_api.Capability, yyrl1429)
			}
			yyc1429 = true
			yyrr1429 = len(yyv1429)
		} else if yyl1429 != len(yyv1429) {
			yyv1429 = yyv1429[:yyl1429]
			yyc1429 = true
		}
		yyj1429 := 0
		for ; yyj1429 < yyrr1429; yyj1429++ {
			yyh1429.ElemContainerState(yyj1429)
			if r.TryDecodeAsNil() {
				yyv1429[yyj1429] = ""
			} else {
				yyv1429[yyj1429] = pkg2_api.Capability(r.DecodeString())
			}

		}
		if yyrt1429 {
			for ; yyj1429 < yyl1429; yyj1429++ {
				yyv1429 = append(yyv1429, "")
				yyh1429.ElemContainerState(yyj1429)
				if r.TryDecodeAsNil() {
					yyv1429[yyj1429] = ""
				} else {
					yyv1429[yyj1429] = pkg2_api.Capability(r.DecodeString())
				}

			}
		}

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

			if yyj1429 >= len(yyv1429) {
				yyv1429 = append(yyv1429, "") // var yyz1429 pkg2_api.Capability
				yyc1429 = true
			}
			yyh1429.ElemContainerState(yyj1429)
			if yyj1429 < len(yyv1429) {
				if r.TryDecodeAsNil() {
					yyv1429[yyj1429] = ""
				} else {
					yyv1429[yyj1429] = pkg2_api.Capability(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1429 < len(yyv1429) {
			yyv1429 = yyv1429[:yyj1429]
			yyc1429 = true
		} else if yyj1429 == 0 && yyv1429 == nil {
			yyv1429 = []pkg2_api.Capability{}
			yyc1429 = true
		}
	}
	yyh1429.End()
	if yyc1429 {
		*v = yyv1429
	}
}

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

	yyv1434 := *v
	yyh1434, yyl1434 := z.DecSliceHelperStart()
	var yyc1434 bool
	if yyl1434 == 0 {
		if yyv1434 == nil {
			yyv1434 = []FSType{}
			yyc1434 = true
		} else if len(yyv1434) != 0 {
			yyv1434 = yyv1434[:0]
			yyc1434 = true
		}
	} else if yyl1434 > 0 {
		var yyrr1434, yyrl1434 int
		var yyrt1434 bool
		if yyl1434 > cap(yyv1434) {

			yyrl1434, yyrt1434 = z.DecInferLen(yyl1434, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1434 {
				if yyrl1434 <= cap(yyv1434) {
					yyv1434 = yyv1434[:yyrl1434]
				} else {
					yyv1434 = make([]FSType, yyrl1434)
				}
			} else {
				yyv1434 = make([]FSType, yyrl1434)
			}
			yyc1434 = true
			yyrr1434 = len(yyv1434)
		} else if yyl1434 != len(yyv1434) {
			yyv1434 = yyv1434[:yyl1434]
			yyc1434 = true
		}
		yyj1434 := 0
		for ; yyj1434 < yyrr1434; yyj1434++ {
			yyh1434.ElemContainerState(yyj1434)
			if r.TryDecodeAsNil() {
				yyv1434[yyj1434] = ""
			} else {
				yyv1434[yyj1434] = FSType(r.DecodeString())
			}

		}
		if yyrt1434 {
			for ; yyj1434 < yyl1434; yyj1434++ {
				yyv1434 = append(yyv1434, "")
				yyh1434.ElemContainerState(yyj1434)
				if r.TryDecodeAsNil() {
					yyv1434[yyj1434] = ""
				} else {
					yyv1434[yyj1434] = FSType(r.DecodeString())
				}

			}
		}

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

			if yyj1434 >= len(yyv1434) {
				yyv1434 = append(yyv1434, "") // var yyz1434 FSType
				yyc1434 = true
			}
			yyh1434.ElemContainerState(yyj1434)
			if yyj1434 < len(yyv1434) {
				if r.TryDecodeAsNil() {
					yyv1434[yyj1434] = ""
				} else {
					yyv1434[yyj1434] = FSType(r.DecodeString())
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1434 < len(yyv1434) {
			yyv1434 = yyv1434[:yyj1434]
			yyc1434 = true
		} else if yyj1434 == 0 && yyv1434 == nil {
			yyv1434 = []FSType{}
			yyc1434 = true
		}
	}
	yyh1434.End()
	if yyc1434 {
		*v = yyv1434
	}
}

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

	yyv1440 := *v
	yyh1440, yyl1440 := z.DecSliceHelperStart()
	var yyc1440 bool
	if yyl1440 == 0 {
		if yyv1440 == nil {
			yyv1440 = []HostPortRange{}
			yyc1440 = true
		} else if len(yyv1440) != 0 {
			yyv1440 = yyv1440[:0]
			yyc1440 = true
		}
	} else if yyl1440 > 0 {
		var yyrr1440, yyrl1440 int
		var yyrt1440 bool
		if yyl1440 > cap(yyv1440) {

			yyrg1440 := len(yyv1440) > 0
			yyv21440 := yyv1440
			yyrl1440, yyrt1440 = z.DecInferLen(yyl1440, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1440 {
				if yyrl1440 <= cap(yyv1440) {
					yyv1440 = yyv1440[:yyrl1440]
				} else {
					yyv1440 = make([]HostPortRange, yyrl1440)
				}
			} else {
				yyv1440 = make([]HostPortRange, yyrl1440)
			}
			yyc1440 = true
			yyrr1440 = len(yyv1440)
			if yyrg1440 {
				copy(yyv1440, yyv21440)
			}
		} else if yyl1440 != len(yyv1440) {
			yyv1440 = yyv1440[:yyl1440]
			yyc1440 = true
		}
		yyj1440 := 0
		for ; yyj1440 < yyrr1440; yyj1440++ {
			yyh1440.ElemContainerState(yyj1440)
			if r.TryDecodeAsNil() {
				yyv1440[yyj1440] = HostPortRange{}
			} else {
				yyv1441 := &yyv1440[yyj1440]
				yyv1441.CodecDecodeSelf(d)
			}

		}
		if yyrt1440 {
			for ; yyj1440 < yyl1440; yyj1440++ {
				yyv1440 = append(yyv1440, HostPortRange{})
				yyh1440.ElemContainerState(yyj1440)
				if r.TryDecodeAsNil() {
					yyv1440[yyj1440] = HostPortRange{}
				} else {
					yyv1442 := &yyv1440[yyj1440]
					yyv1442.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1440 >= len(yyv1440) {
				yyv1440 = append(yyv1440, HostPortRange{}) // var yyz1440 HostPortRange
				yyc1440 = true
			}
			yyh1440.ElemContainerState(yyj1440)
			if yyj1440 < len(yyv1440) {
				if r.TryDecodeAsNil() {
					yyv1440[yyj1440] = HostPortRange{}
				} else {
					yyv1443 := &yyv1440[yyj1440]
					yyv1443.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1440 < len(yyv1440) {
			yyv1440 = yyv1440[:yyj1440]
			yyc1440 = true
		} else if yyj1440 == 0 && yyv1440 == nil {
			yyv1440 = []HostPortRange{}
			yyc1440 = true
		}
	}
	yyh1440.End()
	if yyc1440 {
		*v = yyv1440
	}
}

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

	yyv1446 := *v
	yyh1446, yyl1446 := z.DecSliceHelperStart()
	var yyc1446 bool
	if yyl1446 == 0 {
		if yyv1446 == nil {
			yyv1446 = []IDRange{}
			yyc1446 = true
		} else if len(yyv1446) != 0 {
			yyv1446 = yyv1446[:0]
			yyc1446 = true
		}
	} else if yyl1446 > 0 {
		var yyrr1446, yyrl1446 int
		var yyrt1446 bool
		if yyl1446 > cap(yyv1446) {

			yyrg1446 := len(yyv1446) > 0
			yyv21446 := yyv1446
			yyrl1446, yyrt1446 = z.DecInferLen(yyl1446, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1446 {
				if yyrl1446 <= cap(yyv1446) {
					yyv1446 = yyv1446[:yyrl1446]
				} else {
					yyv1446 = make([]IDRange, yyrl1446)
				}
			} else {
				yyv1446 = make([]IDRange, yyrl1446)
			}
			yyc1446 = true
			yyrr1446 = len(yyv1446)
			if yyrg1446 {
				copy(yyv1446, yyv21446)
			}
		} else if yyl1446 != len(yyv1446) {
			yyv1446 = yyv1446[:yyl1446]
			yyc1446 = true
		}
		yyj1446 := 0
		for ; yyj1446 < yyrr1446; yyj1446++ {
			yyh1446.ElemContainerState(yyj1446)
			if r.TryDecodeAsNil() {
				yyv1446[yyj1446] = IDRange{}
			} else {
				yyv1447 := &yyv1446[yyj1446]
				yyv1447.CodecDecodeSelf(d)
			}

		}
		if yyrt1446 {
			for ; yyj1446 < yyl1446; yyj1446++ {
				yyv1446 = append(yyv1446, IDRange{})
				yyh1446.ElemContainerState(yyj1446)
				if r.TryDecodeAsNil() {
					yyv1446[yyj1446] = IDRange{}
				} else {
					yyv1448 := &yyv1446[yyj1446]
					yyv1448.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1446 >= len(yyv1446) {
				yyv1446 = append(yyv1446, IDRange{}) // var yyz1446 IDRange
				yyc1446 = true
			}
			yyh1446.ElemContainerState(yyj1446)
			if yyj1446 < len(yyv1446) {
				if r.TryDecodeAsNil() {
					yyv1446[yyj1446] = IDRange{}
				} else {
					yyv1449 := &yyv1446[yyj1446]
					yyv1449.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1446 < len(yyv1446) {
			yyv1446 = yyv1446[:yyj1446]
			yyc1446 = true
		} else if yyj1446 == 0 && yyv1446 == nil {
			yyv1446 = []IDRange{}
			yyc1446 = true
		}
	}
	yyh1446.End()
	if yyc1446 {
		*v = yyv1446
	}
}

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

	yyv1452 := *v
	yyh1452, yyl1452 := z.DecSliceHelperStart()
	var yyc1452 bool
	if yyl1452 == 0 {
		if yyv1452 == nil {
			yyv1452 = []PodSecurityPolicy{}
			yyc1452 = true
		} else if len(yyv1452) != 0 {
			yyv1452 = yyv1452[:0]
			yyc1452 = true
		}
	} else if yyl1452 > 0 {
		var yyrr1452, yyrl1452 int
		var yyrt1452 bool
		if yyl1452 > cap(yyv1452) {

			yyrg1452 := len(yyv1452) > 0
			yyv21452 := yyv1452
			yyrl1452, yyrt1452 = z.DecInferLen(yyl1452, z.DecBasicHandle().MaxInitLen, 552)
			if yyrt1452 {
				if yyrl1452 <= cap(yyv1452) {
					yyv1452 = yyv1452[:yyrl1452]
				} else {
					yyv1452 = make([]PodSecurityPolicy, yyrl1452)
				}
			} else {
				yyv1452 = make([]PodSecurityPolicy, yyrl1452)
			}
			yyc1452 = true
			yyrr1452 = len(yyv1452)
			if yyrg1452 {
				copy(yyv1452, yyv21452)
			}
		} else if yyl1452 != len(yyv1452) {
			yyv1452 = yyv1452[:yyl1452]
			yyc1452 = true
		}
		yyj1452 := 0
		for ; yyj1452 < yyrr1452; yyj1452++ {
			yyh1452.ElemContainerState(yyj1452)
			if r.TryDecodeAsNil() {
				yyv1452[yyj1452] = PodSecurityPolicy{}
			} else {
				yyv1453 := &yyv1452[yyj1452]
				yyv1453.CodecDecodeSelf(d)
			}

		}
		if yyrt1452 {
			for ; yyj1452 < yyl1452; yyj1452++ {
				yyv1452 = append(yyv1452, PodSecurityPolicy{})
				yyh1452.ElemContainerState(yyj1452)
				if r.TryDecodeAsNil() {
					yyv1452[yyj1452] = PodSecurityPolicy{}
				} else {
					yyv1454 := &yyv1452[yyj1452]
					yyv1454.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1452 >= len(yyv1452) {
				yyv1452 = append(yyv1452, PodSecurityPolicy{}) // var yyz1452 PodSecurityPolicy
				yyc1452 = true
			}
			yyh1452.ElemContainerState(yyj1452)
			if yyj1452 < len(yyv1452) {
				if r.TryDecodeAsNil() {
					yyv1452[yyj1452] = PodSecurityPolicy{}
				} else {
					yyv1455 := &yyv1452[yyj1452]
					yyv1455.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1452 < len(yyv1452) {
			yyv1452 = yyv1452[:yyj1452]
			yyc1452 = true
		} else if yyj1452 == 0 && yyv1452 == nil {
			yyv1452 = []PodSecurityPolicy{}
			yyc1452 = true
		}
	}
	yyh1452.End()
	if yyc1452 {
		*v = yyv1452
	}
}

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

	yyv1458 := *v
	yyh1458, yyl1458 := z.DecSliceHelperStart()
	var yyc1458 bool
	if yyl1458 == 0 {
		if yyv1458 == nil {
			yyv1458 = []NetworkPolicyIngressRule{}
			yyc1458 = true
		} else if len(yyv1458) != 0 {
			yyv1458 = yyv1458[:0]
			yyc1458 = true
		}
	} else if yyl1458 > 0 {
		var yyrr1458, yyrl1458 int
		var yyrt1458 bool
		if yyl1458 > cap(yyv1458) {

			yyrg1458 := len(yyv1458) > 0
			yyv21458 := yyv1458
			yyrl1458, yyrt1458 = z.DecInferLen(yyl1458, z.DecBasicHandle().MaxInitLen, 48)
			if yyrt1458 {
				if yyrl1458 <= cap(yyv1458) {
					yyv1458 = yyv1458[:yyrl1458]
				} else {
					yyv1458 = make([]NetworkPolicyIngressRule, yyrl1458)
				}
			} else {
				yyv1458 = make([]NetworkPolicyIngressRule, yyrl1458)
			}
			yyc1458 = true
			yyrr1458 = len(yyv1458)
			if yyrg1458 {
				copy(yyv1458, yyv21458)
			}
		} else if yyl1458 != len(yyv1458) {
			yyv1458 = yyv1458[:yyl1458]
			yyc1458 = true
		}
		yyj1458 := 0
		for ; yyj1458 < yyrr1458; yyj1458++ {
			yyh1458.ElemContainerState(yyj1458)
			if r.TryDecodeAsNil() {
				yyv1458[yyj1458] = NetworkPolicyIngressRule{}
			} else {
				yyv1459 := &yyv1458[yyj1458]
				yyv1459.CodecDecodeSelf(d)
			}

		}
		if yyrt1458 {
			for ; yyj1458 < yyl1458; yyj1458++ {
				yyv1458 = append(yyv1458, NetworkPolicyIngressRule{})
				yyh1458.ElemContainerState(yyj1458)
				if r.TryDecodeAsNil() {
					yyv1458[yyj1458] = NetworkPolicyIngressRule{}
				} else {
					yyv1460 := &yyv1458[yyj1458]
					yyv1460.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1458 >= len(yyv1458) {
				yyv1458 = append(yyv1458, NetworkPolicyIngressRule{}) // var yyz1458 NetworkPolicyIngressRule
				yyc1458 = true
			}
			yyh1458.ElemContainerState(yyj1458)
			if yyj1458 < len(yyv1458) {
				if r.TryDecodeAsNil() {
					yyv1458[yyj1458] = NetworkPolicyIngressRule{}
				} else {
					yyv1461 := &yyv1458[yyj1458]
					yyv1461.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1458 < len(yyv1458) {
			yyv1458 = yyv1458[:yyj1458]
			yyc1458 = true
		} else if yyj1458 == 0 && yyv1458 == nil {
			yyv1458 = []NetworkPolicyIngressRule{}
			yyc1458 = true
		}
	}
	yyh1458.End()
	if yyc1458 {
		*v = yyv1458
	}
}

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

	yyv1464 := *v
	yyh1464, yyl1464 := z.DecSliceHelperStart()
	var yyc1464 bool
	if yyl1464 == 0 {
		if yyv1464 == nil {
			yyv1464 = []NetworkPolicyPort{}
			yyc1464 = true
		} else if len(yyv1464) != 0 {
			yyv1464 = yyv1464[:0]
			yyc1464 = true
		}
	} else if yyl1464 > 0 {
		var yyrr1464, yyrl1464 int
		var yyrt1464 bool
		if yyl1464 > cap(yyv1464) {

			yyrg1464 := len(yyv1464) > 0
			yyv21464 := yyv1464
			yyrl1464, yyrt1464 = z.DecInferLen(yyl1464, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1464 {
				if yyrl1464 <= cap(yyv1464) {
					yyv1464 = yyv1464[:yyrl1464]
				} else {
					yyv1464 = make([]NetworkPolicyPort, yyrl1464)
				}
			} else {
				yyv1464 = make([]NetworkPolicyPort, yyrl1464)
			}
			yyc1464 = true
			yyrr1464 = len(yyv1464)
			if yyrg1464 {
				copy(yyv1464, yyv21464)
			}
		} else if yyl1464 != len(yyv1464) {
			yyv1464 = yyv1464[:yyl1464]
			yyc1464 = true
		}
		yyj1464 := 0
		for ; yyj1464 < yyrr1464; yyj1464++ {
			yyh1464.ElemContainerState(yyj1464)
			if r.TryDecodeAsNil() {
				yyv1464[yyj1464] = NetworkPolicyPort{}
			} else {
				yyv1465 := &yyv1464[yyj1464]
				yyv1465.CodecDecodeSelf(d)
			}

		}
		if yyrt1464 {
			for ; yyj1464 < yyl1464; yyj1464++ {
				yyv1464 = append(yyv1464, NetworkPolicyPort{})
				yyh1464.ElemContainerState(yyj1464)
				if r.TryDecodeAsNil() {
					yyv1464[yyj1464] = NetworkPolicyPort{}
				} else {
					yyv1466 := &yyv1464[yyj1464]
					yyv1466.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1464 >= len(yyv1464) {
				yyv1464 = append(yyv1464, NetworkPolicyPort{}) // var yyz1464 NetworkPolicyPort
				yyc1464 = true
			}
			yyh1464.ElemContainerState(yyj1464)
			if yyj1464 < len(yyv1464) {
				if r.TryDecodeAsNil() {
					yyv1464[yyj1464] = NetworkPolicyPort{}
				} else {
					yyv1467 := &yyv1464[yyj1464]
					yyv1467.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1464 < len(yyv1464) {
			yyv1464 = yyv1464[:yyj1464]
			yyc1464 = true
		} else if yyj1464 == 0 && yyv1464 == nil {
			yyv1464 = []NetworkPolicyPort{}
			yyc1464 = true
		}
	}
	yyh1464.End()
	if yyc1464 {
		*v = yyv1464
	}
}

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

	yyv1470 := *v
	yyh1470, yyl1470 := z.DecSliceHelperStart()
	var yyc1470 bool
	if yyl1470 == 0 {
		if yyv1470 == nil {
			yyv1470 = []NetworkPolicyPeer{}
			yyc1470 = true
		} else if len(yyv1470) != 0 {
			yyv1470 = yyv1470[:0]
			yyc1470 = true
		}
	} else if yyl1470 > 0 {
		var yyrr1470, yyrl1470 int
		var yyrt1470 bool
		if yyl1470 > cap(yyv1470) {

			yyrg1470 := len(yyv1470) > 0
			yyv21470 := yyv1470
			yyrl1470, yyrt1470 = z.DecInferLen(yyl1470, z.DecBasicHandle().MaxInitLen, 16)
			if yyrt1470 {
				if yyrl1470 <= cap(yyv1470) {
					yyv1470 = yyv1470[:yyrl1470]
				} else {
					yyv1470 = make([]NetworkPolicyPeer, yyrl1470)
				}
			} else {
				yyv1470 = make([]NetworkPolicyPeer, yyrl1470)
			}
			yyc1470 = true
			yyrr1470 = len(yyv1470)
			if yyrg1470 {
				copy(yyv1470, yyv21470)
			}
		} else if yyl1470 != len(yyv1470) {
			yyv1470 = yyv1470[:yyl1470]
			yyc1470 = true
		}
		yyj1470 := 0
		for ; yyj1470 < yyrr1470; yyj1470++ {
			yyh1470.ElemContainerState(yyj1470)
			if r.TryDecodeAsNil() {
				yyv1470[yyj1470] = NetworkPolicyPeer{}
			} else {
				yyv1471 := &yyv1470[yyj1470]
				yyv1471.CodecDecodeSelf(d)
			}

		}
		if yyrt1470 {
			for ; yyj1470 < yyl1470; yyj1470++ {
				yyv1470 = append(yyv1470, NetworkPolicyPeer{})
				yyh1470.ElemContainerState(yyj1470)
				if r.TryDecodeAsNil() {
					yyv1470[yyj1470] = NetworkPolicyPeer{}
				} else {
					yyv1472 := &yyv1470[yyj1470]
					yyv1472.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1470 >= len(yyv1470) {
				yyv1470 = append(yyv1470, NetworkPolicyPeer{}) // var yyz1470 NetworkPolicyPeer
				yyc1470 = true
			}
			yyh1470.ElemContainerState(yyj1470)
			if yyj1470 < len(yyv1470) {
				if r.TryDecodeAsNil() {
					yyv1470[yyj1470] = NetworkPolicyPeer{}
				} else {
					yyv1473 := &yyv1470[yyj1470]
					yyv1473.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1470 < len(yyv1470) {
			yyv1470 = yyv1470[:yyj1470]
			yyc1470 = true
		} else if yyj1470 == 0 && yyv1470 == nil {
			yyv1470 = []NetworkPolicyPeer{}
			yyc1470 = true
		}
	}
	yyh1470.End()
	if yyc1470 {
		*v = yyv1470
	}
}

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

	yyv1476 := *v
	yyh1476, yyl1476 := z.DecSliceHelperStart()
	var yyc1476 bool
	if yyl1476 == 0 {
		if yyv1476 == nil {
			yyv1476 = []NetworkPolicy{}
			yyc1476 = true
		} else if len(yyv1476) != 0 {
			yyv1476 = yyv1476[:0]
			yyc1476 = true
		}
	} else if yyl1476 > 0 {
		var yyrr1476, yyrl1476 int
		var yyrt1476 bool
		if yyl1476 > cap(yyv1476) {

			yyrg1476 := len(yyv1476) > 0
			yyv21476 := yyv1476
			yyrl1476, yyrt1476 = z.DecInferLen(yyl1476, z.DecBasicHandle().MaxInitLen, 312)
			if yyrt1476 {
				if yyrl1476 <= cap(yyv1476) {
					yyv1476 = yyv1476[:yyrl1476]
				} else {
					yyv1476 = make([]NetworkPolicy, yyrl1476)
				}
			} else {
				yyv1476 = make([]NetworkPolicy, yyrl1476)
			}
			yyc1476 = true
			yyrr1476 = len(yyv1476)
			if yyrg1476 {
				copy(yyv1476, yyv21476)
			}
		} else if yyl1476 != len(yyv1476) {
			yyv1476 = yyv1476[:yyl1476]
			yyc1476 = true
		}
		yyj1476 := 0
		for ; yyj1476 < yyrr1476; yyj1476++ {
			yyh1476.ElemContainerState(yyj1476)
			if r.TryDecodeAsNil() {
				yyv1476[yyj1476] = NetworkPolicy{}
			} else {
				yyv1477 := &yyv1476[yyj1476]
				yyv1477.CodecDecodeSelf(d)
			}

		}
		if yyrt1476 {
			for ; yyj1476 < yyl1476; yyj1476++ {
				yyv1476 = append(yyv1476, NetworkPolicy{})
				yyh1476.ElemContainerState(yyj1476)
				if r.TryDecodeAsNil() {
					yyv1476[yyj1476] = NetworkPolicy{}
				} else {
					yyv1478 := &yyv1476[yyj1476]
					yyv1478.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1476 >= len(yyv1476) {
				yyv1476 = append(yyv1476, NetworkPolicy{}) // var yyz1476 NetworkPolicy
				yyc1476 = true
			}
			yyh1476.ElemContainerState(yyj1476)
			if yyj1476 < len(yyv1476) {
				if r.TryDecodeAsNil() {
					yyv1476[yyj1476] = NetworkPolicy{}
				} else {
					yyv1479 := &yyv1476[yyj1476]
					yyv1479.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1476 < len(yyv1476) {
			yyv1476 = yyv1476[:yyj1476]
			yyc1476 = true
		} else if yyj1476 == 0 && yyv1476 == nil {
			yyv1476 = []NetworkPolicy{}
			yyc1476 = true
		}
	}
	yyh1476.End()
	if yyc1476 {
		*v = yyv1476
	}
}
