github.com/smithx10/nomad@v0.9.1-rc1/nomad/structs/structs.generated.go

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

package structs

import (
	"errors"
	"fmt"
	pkg1_raft "github.com/hashicorp/raft"
	codec1978 "github.com/ugorji/go/codec"
	"reflect"
	"runtime"
	time "time"
)

const (
	// ----- content types ----
	codecSelferC_UTF8100 = 1
	codecSelferC_RAW100  = 0
	// ----- value types used ----
	codecSelferValueTypeArray100 = 10
	codecSelferValueTypeMap100   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey100    = 2
	codecSelfer_containerMapValue100  = 3
	codecSelfer_containerMapEnd100    = 4
	codecSelfer_containerArrayElem100 = 6
	codecSelfer_containerArrayEnd100  = 7
)

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

type codecSelfer100 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 pkg1_raft.ServerID
		var v1 time.Duration
		_, _ = v0, v1
	}
}

func (x Bitmap) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 {
			h.encBitmap((Bitmap)(x), e)
		}
	}
}

func (x *Bitmap) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		h.decBitmap((*Bitmap)(x), d)
	}
}

func (x DiffType) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	yym1 := z.EncBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.EncExt(x) {
	} else {
		r.EncodeString(codecSelferC_UTF8100, string(x))
	}
}

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

func (x *JobDiff) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 5
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Type"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ID"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Fields"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Objects"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.TaskGroups == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else {
						h.encSlicePtrtoTaskGroupDiff(([]*TaskGroupDiff)(x.TaskGroups), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("TaskGroups"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.TaskGroups == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else {
						h.encSlicePtrtoTaskGroupDiff(([]*TaskGroupDiff)(x.TaskGroups), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *JobDiff) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *JobDiff) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv4 := &x.Type
				yyv4.CodecDecodeSelf(d)
			}
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv5 := &x.ID
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}
		case "Fields":
			if r.TryDecodeAsNil() {
				x.Fields = nil
			} else {
				yyv7 := &x.Fields
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv7), d)
				}
			}
		case "Objects":
			if r.TryDecodeAsNil() {
				x.Objects = nil
			} else {
				yyv9 := &x.Objects
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv9), d)
				}
			}
		case "TaskGroups":
			if r.TryDecodeAsNil() {
				x.TaskGroups = nil
			} else {
				yyv11 := &x.TaskGroups
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					h.decSlicePtrtoTaskGroupDiff((*[]*TaskGroupDiff)(yyv11), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *JobDiff) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj13 int
	var yyb13 bool
	var yyhl13 bool = l >= 0
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv14 := &x.Type
		yyv14.CodecDecodeSelf(d)
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv15 := &x.ID
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Fields = nil
	} else {
		yyv17 := &x.Fields
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv17), d)
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Objects = nil
	} else {
		yyv19 := &x.Objects
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv19), d)
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.TaskGroups = nil
	} else {
		yyv21 := &x.TaskGroups
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			h.decSlicePtrtoTaskGroupDiff((*[]*TaskGroupDiff)(yyv21), d)
		}
	}
	for {
		yyj13++
		if yyhl13 {
			yyb13 = yyj13 > l
		} else {
			yyb13 = r.CheckBreak()
		}
		if yyb13 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj13-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *TaskGroupDiff) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [6]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(6)
			} else {
				yynn2 = 6
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Type"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Name"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Fields"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Objects"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Tasks == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else {
						h.encSlicePtrtoTaskDiff(([]*TaskDiff)(x.Tasks), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Tasks"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Tasks == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else {
						h.encSlicePtrtoTaskDiff(([]*TaskDiff)(x.Tasks), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Updates == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else {
						z.F.EncMapStringUint64V(x.Updates, false, e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Updates"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Updates == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else {
						z.F.EncMapStringUint64V(x.Updates, false, e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *TaskGroupDiff) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *TaskGroupDiff) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv4 := &x.Type
				yyv4.CodecDecodeSelf(d)
			}
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				yyv5 := &x.Name
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}
		case "Fields":
			if r.TryDecodeAsNil() {
				x.Fields = nil
			} else {
				yyv7 := &x.Fields
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv7), d)
				}
			}
		case "Objects":
			if r.TryDecodeAsNil() {
				x.Objects = nil
			} else {
				yyv9 := &x.Objects
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv9), d)
				}
			}
		case "Tasks":
			if r.TryDecodeAsNil() {
				x.Tasks = nil
			} else {
				yyv11 := &x.Tasks
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					h.decSlicePtrtoTaskDiff((*[]*TaskDiff)(yyv11), d)
				}
			}
		case "Updates":
			if r.TryDecodeAsNil() {
				x.Updates = nil
			} else {
				yyv13 := &x.Updates
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else {
					z.F.DecMapStringUint64X(yyv13, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *TaskGroupDiff) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv16 := &x.Type
		yyv16.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		yyv17 := &x.Name
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*string)(yyv17)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Fields = nil
	} else {
		yyv19 := &x.Fields
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv19), d)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Objects = nil
	} else {
		yyv21 := &x.Objects
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv21), d)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Tasks = nil
	} else {
		yyv23 := &x.Tasks
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			h.decSlicePtrtoTaskDiff((*[]*TaskDiff)(yyv23), d)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Updates = nil
	} else {
		yyv25 := &x.Updates
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			z.F.DecMapStringUint64X(yyv25, false, d)
		}
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x TaskGroupDiffs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 {
			h.encTaskGroupDiffs((TaskGroupDiffs)(x), e)
		}
	}
}

func (x *TaskGroupDiffs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		h.decTaskGroupDiffs((*TaskGroupDiffs)(x), d)
	}
}

func (x *TaskDiff) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 5
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Type"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Name"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Fields"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Objects"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Annotations == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else {
						z.F.EncSliceStringV(x.Annotations, false, e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Annotations"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Annotations == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else {
						z.F.EncSliceStringV(x.Annotations, false, e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *TaskDiff) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *TaskDiff) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv4 := &x.Type
				yyv4.CodecDecodeSelf(d)
			}
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				yyv5 := &x.Name
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}
		case "Fields":
			if r.TryDecodeAsNil() {
				x.Fields = nil
			} else {
				yyv7 := &x.Fields
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv7), d)
				}
			}
		case "Objects":
			if r.TryDecodeAsNil() {
				x.Objects = nil
			} else {
				yyv9 := &x.Objects
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv9), d)
				}
			}
		case "Annotations":
			if r.TryDecodeAsNil() {
				x.Annotations = nil
			} else {
				yyv11 := &x.Annotations
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					z.F.DecSliceStringX(yyv11, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *TaskDiff) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj13 int
	var yyb13 bool
	var yyhl13 bool = l >= 0
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv14 := &x.Type
		yyv14.CodecDecodeSelf(d)
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		yyv15 := &x.Name
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Fields = nil
	} else {
		yyv17 := &x.Fields
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv17), d)
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Objects = nil
	} else {
		yyv19 := &x.Objects
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv19), d)
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Annotations = nil
	} else {
		yyv21 := &x.Annotations
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			z.F.DecSliceStringX(yyv21, false, d)
		}
	}
	for {
		yyj13++
		if yyhl13 {
			yyb13 = yyj13 > l
		} else {
			yyb13 = r.CheckBreak()
		}
		if yyb13 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj13-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x TaskDiffs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 {
			h.encTaskDiffs((TaskDiffs)(x), e)
		}
	}
}

func (x *TaskDiffs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		h.decTaskDiffs((*TaskDiffs)(x), d)
	}
}

func (x *ObjectDiff) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [4]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(4)
			} else {
				yynn2 = 4
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Type"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Name"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Fields"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Fields == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						h.encSlicePtrtoFieldDiff(([]*FieldDiff)(x.Fields), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Objects"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Objects == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						h.encSlicePtrtoObjectDiff(([]*ObjectDiff)(x.Objects), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *ObjectDiff) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *ObjectDiff) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv4 := &x.Type
				yyv4.CodecDecodeSelf(d)
			}
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				yyv5 := &x.Name
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}
		case "Fields":
			if r.TryDecodeAsNil() {
				x.Fields = nil
			} else {
				yyv7 := &x.Fields
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv7), d)
				}
			}
		case "Objects":
			if r.TryDecodeAsNil() {
				x.Objects = nil
			} else {
				yyv9 := &x.Objects
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv9), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *ObjectDiff) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj11 int
	var yyb11 bool
	var yyhl11 bool = l >= 0
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv12 := &x.Type
		yyv12.CodecDecodeSelf(d)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		yyv13 := &x.Name
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*string)(yyv13)) = r.DecodeString()
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Fields = nil
	} else {
		yyv15 := &x.Fields
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			h.decSlicePtrtoFieldDiff((*[]*FieldDiff)(yyv15), d)
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Objects = nil
	} else {
		yyv17 := &x.Objects
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			h.decSlicePtrtoObjectDiff((*[]*ObjectDiff)(yyv17), d)
		}
	}
	for {
		yyj11++
		if yyhl11 {
			yyb11 = yyj11 > l
		} else {
			yyb11 = r.CheckBreak()
		}
		if yyb11 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj11-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x ObjectDiffs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 {
			h.encObjectDiffs((ObjectDiffs)(x), e)
		}
	}
}

func (x *ObjectDiffs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		h.decObjectDiffs((*ObjectDiffs)(x), d)
	}
}

func (x *FieldDiff) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 5
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				x.Type.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Type"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				x.Type.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Name"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Old))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Old"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Old))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.New))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("New"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.New))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Annotations == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else {
						z.F.EncSliceStringV(x.Annotations, false, e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Annotations"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Annotations == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else {
						z.F.EncSliceStringV(x.Annotations, false, e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *FieldDiff) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *FieldDiff) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv4 := &x.Type
				yyv4.CodecDecodeSelf(d)
			}
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				yyv5 := &x.Name
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}
		case "Old":
			if r.TryDecodeAsNil() {
				x.Old = ""
			} else {
				yyv7 := &x.Old
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*string)(yyv7)) = r.DecodeString()
				}
			}
		case "New":
			if r.TryDecodeAsNil() {
				x.New = ""
			} else {
				yyv9 := &x.New
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*string)(yyv9)) = r.DecodeString()
				}
			}
		case "Annotations":
			if r.TryDecodeAsNil() {
				x.Annotations = nil
			} else {
				yyv11 := &x.Annotations
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					z.F.DecSliceStringX(yyv11, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *FieldDiff) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj13 int
	var yyb13 bool
	var yyhl13 bool = l >= 0
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv14 := &x.Type
		yyv14.CodecDecodeSelf(d)
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		yyv15 := &x.Name
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Old = ""
	} else {
		yyv17 := &x.Old
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*string)(yyv17)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.New = ""
	} else {
		yyv19 := &x.New
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Annotations = nil
	} else {
		yyv21 := &x.Annotations
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			z.F.DecSliceStringX(yyv21, false, d)
		}
	}
	for {
		yyj13++
		if yyhl13 {
			yyb13 = yyj13 > l
		} else {
			yyb13 = r.CheckBreak()
		}
		if yyb13 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj13-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x FieldDiffs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 {
			h.encFieldDiffs((FieldDiffs)(x), e)
		}
	}
}

func (x *FieldDiffs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		h.decFieldDiffs((*FieldDiffs)(x), d)
	}
}

func (x *NetworkIndex) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [4]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(4)
			} else {
				yynn2 = 4
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.AvailNetworks == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						h.encSlicePtrtoNetworkResource(([]*NetworkResource)(x.AvailNetworks), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AvailNetworks"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.AvailNetworks == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						h.encSlicePtrtoNetworkResource(([]*NetworkResource)(x.AvailNetworks), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.AvailBandwidth == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else {
						z.F.EncMapStringIntV(x.AvailBandwidth, false, e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AvailBandwidth"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.AvailBandwidth == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else {
						z.F.EncMapStringIntV(x.AvailBandwidth, false, e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.UsedPorts == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						h.encMapstringBitmap((map[string]Bitmap)(x.UsedPorts), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("UsedPorts"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.UsedPorts == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						h.encMapstringBitmap((map[string]Bitmap)(x.UsedPorts), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.UsedBandwidth == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						z.F.EncMapStringIntV(x.UsedBandwidth, false, e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("UsedBandwidth"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.UsedBandwidth == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						z.F.EncMapStringIntV(x.UsedBandwidth, false, e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *NetworkIndex) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *NetworkIndex) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "AvailNetworks":
			if r.TryDecodeAsNil() {
				x.AvailNetworks = nil
			} else {
				yyv4 := &x.AvailNetworks
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					h.decSlicePtrtoNetworkResource((*[]*NetworkResource)(yyv4), d)
				}
			}
		case "AvailBandwidth":
			if r.TryDecodeAsNil() {
				x.AvailBandwidth = nil
			} else {
				yyv6 := &x.AvailBandwidth
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					z.F.DecMapStringIntX(yyv6, false, d)
				}
			}
		case "UsedPorts":
			if r.TryDecodeAsNil() {
				x.UsedPorts = nil
			} else {
				yyv8 := &x.UsedPorts
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					h.decMapstringBitmap((*map[string]Bitmap)(yyv8), d)
				}
			}
		case "UsedBandwidth":
			if r.TryDecodeAsNil() {
				x.UsedBandwidth = nil
			} else {
				yyv10 := &x.UsedBandwidth
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					z.F.DecMapStringIntX(yyv10, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *NetworkIndex) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj12 int
	var yyb12 bool
	var yyhl12 bool = l >= 0
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AvailNetworks = nil
	} else {
		yyv13 := &x.AvailNetworks
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			h.decSlicePtrtoNetworkResource((*[]*NetworkResource)(yyv13), d)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AvailBandwidth = nil
	} else {
		yyv15 := &x.AvailBandwidth
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			z.F.DecMapStringIntX(yyv15, false, d)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.UsedPorts = nil
	} else {
		yyv17 := &x.UsedPorts
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			h.decMapstringBitmap((*map[string]Bitmap)(yyv17), d)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.UsedBandwidth = nil
	} else {
		yyv19 := &x.UsedBandwidth
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			z.F.DecMapStringIntX(yyv19, false, d)
		}
	}
	for {
		yyj12++
		if yyhl12 {
			yyb12 = yyj12 > l
		} else {
			yyb12 = r.CheckBreak()
		}
		if yyb12 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj12-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *RaftServer) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [6]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(6)
			} else {
				yynn2 = 6
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ID) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ID"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ID) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Node))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Node"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Node))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Address) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Address"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Address) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeBool(bool(x.Leader))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Leader"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeBool(bool(x.Leader))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeBool(bool(x.Voter))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Voter"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym17 := z.EncBinary()
				_ = yym17
				if false {
				} else {
					r.EncodeBool(bool(x.Voter))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.RaftProtocol))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("RaftProtocol"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.RaftProtocol))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *RaftServer) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *RaftServer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "Node":
			if r.TryDecodeAsNil() {
				x.Node = ""
			} else {
				yyv6 := &x.Node
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "Address":
			if r.TryDecodeAsNil() {
				x.Address = ""
			} else {
				yyv8 := &x.Address
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "Leader":
			if r.TryDecodeAsNil() {
				x.Leader = false
			} else {
				yyv10 := &x.Leader
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*bool)(yyv10)) = r.DecodeBool()
				}
			}
		case "Voter":
			if r.TryDecodeAsNil() {
				x.Voter = false
			} else {
				yyv12 := &x.Voter
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else {
					*((*bool)(yyv12)) = r.DecodeBool()
				}
			}
		case "RaftProtocol":
			if r.TryDecodeAsNil() {
				x.RaftProtocol = ""
			} else {
				yyv14 := &x.RaftProtocol
				yym15 := z.DecBinary()
				_ = yym15
				if false {
				} else {
					*((*string)(yyv14)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *RaftServer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj16 int
	var yyb16 bool
	var yyhl16 bool = l >= 0
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv17 := &x.ID
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv17) {
		} else {
			*((*string)(yyv17)) = r.DecodeString()
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Node = ""
	} else {
		yyv19 := &x.Node
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Address = ""
	} else {
		yyv21 := &x.Address
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv21) {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Leader = false
	} else {
		yyv23 := &x.Leader
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*bool)(yyv23)) = r.DecodeBool()
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Voter = false
	} else {
		yyv25 := &x.Voter
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			*((*bool)(yyv25)) = r.DecodeBool()
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.RaftProtocol = ""
	} else {
		yyv27 := &x.RaftProtocol
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else {
			*((*string)(yyv27)) = r.DecodeString()
		}
	}
	for {
		yyj16++
		if yyhl16 {
			yyb16 = yyj16 > l
		} else {
			yyb16 = r.CheckBreak()
		}
		if yyb16 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj16-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *RaftConfigurationResponse) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [2]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(2)
			} else {
				yynn2 = 2
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.Servers == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						h.encSlicePtrtoRaftServer(([]*RaftServer)(x.Servers), e)
					}
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Servers"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.Servers == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						h.encSlicePtrtoRaftServer(([]*RaftServer)(x.Servers), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Index"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *RaftConfigurationResponse) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *RaftConfigurationResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Servers":
			if r.TryDecodeAsNil() {
				x.Servers = nil
			} else {
				yyv4 := &x.Servers
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					h.decSlicePtrtoRaftServer((*[]*RaftServer)(yyv4), d)
				}
			}
		case "Index":
			if r.TryDecodeAsNil() {
				x.Index = 0
			} else {
				yyv6 := &x.Index
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *RaftConfigurationResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj8 int
	var yyb8 bool
	var yyhl8 bool = l >= 0
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Servers = nil
	} else {
		yyv9 := &x.Servers
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			h.decSlicePtrtoRaftServer((*[]*RaftServer)(yyv9), d)
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Index = 0
	} else {
		yyv11 := &x.Index
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *RaftPeerByAddressRequest) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 5
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Address) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Address"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Address) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Region"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym17 := z.EncBinary()
				_ = yym17
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *RaftPeerByAddressRequest) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *RaftPeerByAddressRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Address":
			if r.TryDecodeAsNil() {
				x.Address = ""
			} else {
				yyv4 := &x.Address
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "Region":
			if r.TryDecodeAsNil() {
				x.Region = ""
			} else {
				yyv6 := &x.Region
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "Namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				yyv8 := &x.Namespace
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "AuthToken":
			if r.TryDecodeAsNil() {
				x.AuthToken = ""
			} else {
				yyv10 := &x.AuthToken
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*string)(yyv10)) = r.DecodeString()
				}
			}
		case "Forwarded":
			if r.TryDecodeAsNil() {
				x.Forwarded = false
			} else {
				yyv12 := &x.Forwarded
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else {
					*((*bool)(yyv12)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *RaftPeerByAddressRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj14 int
	var yyb14 bool
	var yyhl14 bool = l >= 0
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Address = ""
	} else {
		yyv15 := &x.Address
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Region = ""
	} else {
		yyv17 := &x.Region
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*string)(yyv17)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Namespace = ""
	} else {
		yyv19 := &x.Namespace
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AuthToken = ""
	} else {
		yyv21 := &x.AuthToken
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Forwarded = false
	} else {
		yyv23 := &x.Forwarded
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*bool)(yyv23)) = r.DecodeBool()
		}
	}
	for {
		yyj14++
		if yyhl14 {
			yyb14 = yyj14 > l
		} else {
			yyb14 = r.CheckBreak()
		}
		if yyb14 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj14-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *RaftPeerByIDRequest) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [5]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(5)
			} else {
				yynn2 = 5
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ID) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ID"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ID) {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Region"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym17 := z.EncBinary()
				_ = yym17
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *RaftPeerByIDRequest) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *RaftPeerByIDRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "Region":
			if r.TryDecodeAsNil() {
				x.Region = ""
			} else {
				yyv6 := &x.Region
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "Namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				yyv8 := &x.Namespace
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "AuthToken":
			if r.TryDecodeAsNil() {
				x.AuthToken = ""
			} else {
				yyv10 := &x.AuthToken
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*string)(yyv10)) = r.DecodeString()
				}
			}
		case "Forwarded":
			if r.TryDecodeAsNil() {
				x.Forwarded = false
			} else {
				yyv12 := &x.Forwarded
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else {
					*((*bool)(yyv12)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *RaftPeerByIDRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj14 int
	var yyb14 bool
	var yyhl14 bool = l >= 0
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv15 := &x.ID
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Region = ""
	} else {
		yyv17 := &x.Region
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*string)(yyv17)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Namespace = ""
	} else {
		yyv19 := &x.Namespace
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AuthToken = ""
	} else {
		yyv21 := &x.AuthToken
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Forwarded = false
	} else {
		yyv23 := &x.Forwarded
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*bool)(yyv23)) = r.DecodeBool()
		}
	}
	for {
		yyj14++
		if yyhl14 {
			yyb14 = yyj14 > l
		} else {
			yyb14 = r.CheckBreak()
		}
		if yyb14 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj14-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *AutopilotSetConfigRequest) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [7]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(7)
			} else {
				yynn2 = 7
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Datacenter"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yy7 := &x.Config
				yy7.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Config"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yy9 := &x.Config
				yy9.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym12 := z.EncBinary()
				_ = yym12
				if false {
				} else {
					r.EncodeBool(bool(x.CAS))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("CAS"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeBool(bool(x.CAS))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Region"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym18 := z.EncBinary()
				_ = yym18
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym21 := z.EncBinary()
				_ = yym21
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym24 := z.EncBinary()
				_ = yym24
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *AutopilotSetConfigRequest) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *AutopilotSetConfigRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Datacenter":
			if r.TryDecodeAsNil() {
				x.Datacenter = ""
			} else {
				yyv4 := &x.Datacenter
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "Config":
			if r.TryDecodeAsNil() {
				x.Config = AutopilotConfig{}
			} else {
				yyv6 := &x.Config
				yyv6.CodecDecodeSelf(d)
			}
		case "CAS":
			if r.TryDecodeAsNil() {
				x.CAS = false
			} else {
				yyv7 := &x.CAS
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*bool)(yyv7)) = r.DecodeBool()
				}
			}
		case "Region":
			if r.TryDecodeAsNil() {
				x.Region = ""
			} else {
				yyv9 := &x.Region
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*string)(yyv9)) = r.DecodeString()
				}
			}
		case "Namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				yyv11 := &x.Namespace
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					*((*string)(yyv11)) = r.DecodeString()
				}
			}
		case "AuthToken":
			if r.TryDecodeAsNil() {
				x.AuthToken = ""
			} else {
				yyv13 := &x.AuthToken
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else {
					*((*string)(yyv13)) = r.DecodeString()
				}
			}
		case "Forwarded":
			if r.TryDecodeAsNil() {
				x.Forwarded = false
			} else {
				yyv15 := &x.Forwarded
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else {
					*((*bool)(yyv15)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *AutopilotSetConfigRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj17 int
	var yyb17 bool
	var yyhl17 bool = l >= 0
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Datacenter = ""
	} else {
		yyv18 := &x.Datacenter
		yym19 := z.DecBinary()
		_ = yym19
		if false {
		} else {
			*((*string)(yyv18)) = r.DecodeString()
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Config = AutopilotConfig{}
	} else {
		yyv20 := &x.Config
		yyv20.CodecDecodeSelf(d)
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.CAS = false
	} else {
		yyv21 := &x.CAS
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*bool)(yyv21)) = r.DecodeBool()
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Region = ""
	} else {
		yyv23 := &x.Region
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*string)(yyv23)) = r.DecodeString()
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Namespace = ""
	} else {
		yyv25 := &x.Namespace
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			*((*string)(yyv25)) = r.DecodeString()
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AuthToken = ""
	} else {
		yyv27 := &x.AuthToken
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else {
			*((*string)(yyv27)) = r.DecodeString()
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Forwarded = false
	} else {
		yyv29 := &x.Forwarded
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else {
			*((*bool)(yyv29)) = r.DecodeBool()
		}
	}
	for {
		yyj17++
		if yyhl17 {
			yyb17 = yyj17 > l
		} else {
			yyb17 = r.CheckBreak()
		}
		if yyb17 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj17-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *AutopilotConfig) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [9]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(9)
			} else {
				yynn2 = 9
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeBool(bool(x.CleanupDeadServers))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("CleanupDeadServers"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeBool(bool(x.CleanupDeadServers))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ServerStabilizationTime) {
				} else {
					r.EncodeInt(int64(x.ServerStabilizationTime))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ServerStabilizationTime"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.EncExt(x.ServerStabilizationTime) {
				} else {
					r.EncodeInt(int64(x.ServerStabilizationTime))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else if z.HasExtensions() && z.EncExt(x.LastContactThreshold) {
				} else {
					r.EncodeInt(int64(x.LastContactThreshold))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("LastContactThreshold"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.EncExt(x.LastContactThreshold) {
				} else {
					r.EncodeInt(int64(x.LastContactThreshold))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeUint(uint64(x.MaxTrailingLogs))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("MaxTrailingLogs"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeUint(uint64(x.MaxTrailingLogs))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeBool(bool(x.EnableRedundancyZones))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("EnableRedundancyZones"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym17 := z.EncBinary()
				_ = yym17
				if false {
				} else {
					r.EncodeBool(bool(x.EnableRedundancyZones))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else {
					r.EncodeBool(bool(x.DisableUpgradeMigration))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("DisableUpgradeMigration"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else {
					r.EncodeBool(bool(x.DisableUpgradeMigration))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else {
					r.EncodeBool(bool(x.EnableCustomUpgrades))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("EnableCustomUpgrades"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else {
					r.EncodeBool(bool(x.EnableCustomUpgrades))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeUint(uint64(x.CreateIndex))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else {
					r.EncodeUint(uint64(x.CreateIndex))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym28 := z.EncBinary()
				_ = yym28
				if false {
				} else {
					r.EncodeUint(uint64(x.ModifyIndex))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym29 := z.EncBinary()
				_ = yym29
				if false {
				} else {
					r.EncodeUint(uint64(x.ModifyIndex))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *AutopilotConfig) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *AutopilotConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "CleanupDeadServers":
			if r.TryDecodeAsNil() {
				x.CleanupDeadServers = false
			} else {
				yyv4 := &x.CleanupDeadServers
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*bool)(yyv4)) = r.DecodeBool()
				}
			}
		case "ServerStabilizationTime":
			if r.TryDecodeAsNil() {
				x.ServerStabilizationTime = 0
			} else {
				yyv6 := &x.ServerStabilizationTime
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else {
					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
				}
			}
		case "LastContactThreshold":
			if r.TryDecodeAsNil() {
				x.LastContactThreshold = 0
			} else {
				yyv8 := &x.LastContactThreshold
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
				}
			}
		case "MaxTrailingLogs":
			if r.TryDecodeAsNil() {
				x.MaxTrailingLogs = 0
			} else {
				yyv10 := &x.MaxTrailingLogs
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
				}
			}
		case "EnableRedundancyZones":
			if r.TryDecodeAsNil() {
				x.EnableRedundancyZones = false
			} else {
				yyv12 := &x.EnableRedundancyZones
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else {
					*((*bool)(yyv12)) = r.DecodeBool()
				}
			}
		case "DisableUpgradeMigration":
			if r.TryDecodeAsNil() {
				x.DisableUpgradeMigration = false
			} else {
				yyv14 := &x.DisableUpgradeMigration
				yym15 := z.DecBinary()
				_ = yym15
				if false {
				} else {
					*((*bool)(yyv14)) = r.DecodeBool()
				}
			}
		case "EnableCustomUpgrades":
			if r.TryDecodeAsNil() {
				x.EnableCustomUpgrades = false
			} else {
				yyv16 := &x.EnableCustomUpgrades
				yym17 := z.DecBinary()
				_ = yym17
				if false {
				} else {
					*((*bool)(yyv16)) = r.DecodeBool()
				}
			}
		case "CreateIndex":
			if r.TryDecodeAsNil() {
				x.CreateIndex = 0
			} else {
				yyv18 := &x.CreateIndex
				yym19 := z.DecBinary()
				_ = yym19
				if false {
				} else {
					*((*uint64)(yyv18)) = uint64(r.DecodeUint(64))
				}
			}
		case "ModifyIndex":
			if r.TryDecodeAsNil() {
				x.ModifyIndex = 0
			} else {
				yyv20 := &x.ModifyIndex
				yym21 := z.DecBinary()
				_ = yym21
				if false {
				} else {
					*((*uint64)(yyv20)) = uint64(r.DecodeUint(64))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *AutopilotConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj22 int
	var yyb22 bool
	var yyhl22 bool = l >= 0
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.CleanupDeadServers = false
	} else {
		yyv23 := &x.CleanupDeadServers
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*bool)(yyv23)) = r.DecodeBool()
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ServerStabilizationTime = 0
	} else {
		yyv25 := &x.ServerStabilizationTime
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv25) {
		} else {
			*((*int64)(yyv25)) = int64(r.DecodeInt(64))
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.LastContactThreshold = 0
	} else {
		yyv27 := &x.LastContactThreshold
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv27) {
		} else {
			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.MaxTrailingLogs = 0
	} else {
		yyv29 := &x.MaxTrailingLogs
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else {
			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.EnableRedundancyZones = false
	} else {
		yyv31 := &x.EnableRedundancyZones
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else {
			*((*bool)(yyv31)) = r.DecodeBool()
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.DisableUpgradeMigration = false
	} else {
		yyv33 := &x.DisableUpgradeMigration
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else {
			*((*bool)(yyv33)) = r.DecodeBool()
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.EnableCustomUpgrades = false
	} else {
		yyv35 := &x.EnableCustomUpgrades
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else {
			*((*bool)(yyv35)) = r.DecodeBool()
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.CreateIndex = 0
	} else {
		yyv37 := &x.CreateIndex
		yym38 := z.DecBinary()
		_ = yym38
		if false {
		} else {
			*((*uint64)(yyv37)) = uint64(r.DecodeUint(64))
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ModifyIndex = 0
	} else {
		yyv39 := &x.ModifyIndex
		yym40 := z.DecBinary()
		_ = yym40
		if false {
		} else {
			*((*uint64)(yyv39)) = uint64(r.DecodeUint(64))
		}
	}
	for {
		yyj22++
		if yyhl22 {
			yyb22 = yyj22 > l
		} else {
			yyb22 = r.CheckBreak()
		}
		if yyb22 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj22-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *SchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [3]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(3)
			} else {
				yynn2 = 3
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yy4 := &x.PreemptionConfig
				yy4.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("PreemptionConfig"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yy6 := &x.PreemptionConfig
				yy6.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym9 := z.EncBinary()
				_ = yym9
				if false {
				} else {
					r.EncodeUint(uint64(x.CreateIndex))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeUint(uint64(x.CreateIndex))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym12 := z.EncBinary()
				_ = yym12
				if false {
				} else {
					r.EncodeUint(uint64(x.ModifyIndex))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeUint(uint64(x.ModifyIndex))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *SchedulerConfiguration) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *SchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "PreemptionConfig":
			if r.TryDecodeAsNil() {
				x.PreemptionConfig = PreemptionConfig{}
			} else {
				yyv4 := &x.PreemptionConfig
				yyv4.CodecDecodeSelf(d)
			}
		case "CreateIndex":
			if r.TryDecodeAsNil() {
				x.CreateIndex = 0
			} else {
				yyv5 := &x.CreateIndex
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
				}
			}
		case "ModifyIndex":
			if r.TryDecodeAsNil() {
				x.ModifyIndex = 0
			} else {
				yyv7 := &x.ModifyIndex
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *SchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj9 int
	var yyb9 bool
	var yyhl9 bool = l >= 0
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.PreemptionConfig = PreemptionConfig{}
	} else {
		yyv10 := &x.PreemptionConfig
		yyv10.CodecDecodeSelf(d)
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.CreateIndex = 0
	} else {
		yyv11 := &x.CreateIndex
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
		}
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.ModifyIndex = 0
	} else {
		yyv13 := &x.ModifyIndex
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
		}
	}
	for {
		yyj9++
		if yyhl9 {
			yyb9 = yyj9 > l
		} else {
			yyb9 = r.CheckBreak()
		}
		if yyb9 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj9-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *SchedulerConfigurationResponse) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [4]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(4)
			} else {
				yynn2 = 4
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				if x.SchedulerConfig == nil {
					r.EncodeNil()
				} else {
					x.SchedulerConfig.CodecEncodeSelf(e)
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("SchedulerConfig"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				if x.SchedulerConfig == nil {
					r.EncodeNil()
				} else {
					x.SchedulerConfig.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Index"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
				} else {
					r.EncodeInt(int64(x.LastContact))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
				} else {
					r.EncodeInt(int64(x.LastContact))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeBool(bool(x.KnownLeader))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeBool(bool(x.KnownLeader))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *SchedulerConfigurationResponse) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *SchedulerConfigurationResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "SchedulerConfig":
			if r.TryDecodeAsNil() {
				if x.SchedulerConfig != nil {
					x.SchedulerConfig = nil
				}
			} else {
				if x.SchedulerConfig == nil {
					x.SchedulerConfig = new(SchedulerConfiguration)
				}
				x.SchedulerConfig.CodecDecodeSelf(d)
			}
		case "Index":
			if r.TryDecodeAsNil() {
				x.Index = 0
			} else {
				yyv5 := &x.Index
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
				}
			}
		case "LastContact":
			if r.TryDecodeAsNil() {
				x.LastContact = 0
			} else {
				yyv7 := &x.LastContact
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv7) {
				} else {
					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
				}
			}
		case "KnownLeader":
			if r.TryDecodeAsNil() {
				x.KnownLeader = false
			} else {
				yyv9 := &x.KnownLeader
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*bool)(yyv9)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *SchedulerConfigurationResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj11 int
	var yyb11 bool
	var yyhl11 bool = l >= 0
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		if x.SchedulerConfig != nil {
			x.SchedulerConfig = nil
		}
	} else {
		if x.SchedulerConfig == nil {
			x.SchedulerConfig = new(SchedulerConfiguration)
		}
		x.SchedulerConfig.CodecDecodeSelf(d)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Index = 0
	} else {
		yyv13 := &x.Index
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.LastContact = 0
	} else {
		yyv15 := &x.LastContact
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.KnownLeader = false
	} else {
		yyv17 := &x.KnownLeader
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*bool)(yyv17)) = r.DecodeBool()
		}
	}
	for {
		yyj11++
		if yyhl11 {
			yyb11 = yyj11 > l
		} else {
			yyb11 = r.CheckBreak()
		}
		if yyb11 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj11-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *SchedulerSetConfigurationResponse) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [2]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(2)
			} else {
				yynn2 = 2
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeBool(bool(x.Updated))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Updated"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeBool(bool(x.Updated))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Index"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeUint(uint64(x.Index))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *SchedulerSetConfigurationResponse) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *SchedulerSetConfigurationResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Updated":
			if r.TryDecodeAsNil() {
				x.Updated = false
			} else {
				yyv4 := &x.Updated
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*bool)(yyv4)) = r.DecodeBool()
				}
			}
		case "Index":
			if r.TryDecodeAsNil() {
				x.Index = 0
			} else {
				yyv6 := &x.Index
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *SchedulerSetConfigurationResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj8 int
	var yyb8 bool
	var yyhl8 bool = l >= 0
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Updated = false
	} else {
		yyv9 := &x.Updated
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			*((*bool)(yyv9)) = r.DecodeBool()
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Index = 0
	} else {
		yyv11 := &x.Index
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *PreemptionConfig) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 1
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeBool(bool(x.SystemSchedulerEnabled))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("SystemSchedulerEnabled"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeBool(bool(x.SystemSchedulerEnabled))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *PreemptionConfig) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *PreemptionConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "SystemSchedulerEnabled":
			if r.TryDecodeAsNil() {
				x.SystemSchedulerEnabled = false
			} else {
				yyv4 := &x.SystemSchedulerEnabled
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*bool)(yyv4)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *PreemptionConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj6 int
	var yyb6 bool
	var yyhl6 bool = l >= 0
	yyj6++
	if yyhl6 {
		yyb6 = yyj6 > l
	} else {
		yyb6 = r.CheckBreak()
	}
	if yyb6 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.SystemSchedulerEnabled = false
	} else {
		yyv7 := &x.SystemSchedulerEnabled
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else {
			*((*bool)(yyv7)) = r.DecodeBool()
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *SchedulerSetConfigRequest) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [6]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(6)
			} else {
				yynn2 = 6
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yy4 := &x.Config
				yy4.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Config"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yy6 := &x.Config
				yy6.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym9 := z.EncBinary()
				_ = yym9
				if false {
				} else {
					r.EncodeBool(bool(x.CAS))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("CAS"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeBool(bool(x.CAS))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym12 := z.EncBinary()
				_ = yym12
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Region"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym15 := z.EncBinary()
				_ = yym15
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym18 := z.EncBinary()
				_ = yym18
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym21 := z.EncBinary()
				_ = yym21
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else {
					r.EncodeBool(bool(x.Forwarded))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *SchedulerSetConfigRequest) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *SchedulerSetConfigRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Config":
			if r.TryDecodeAsNil() {
				x.Config = SchedulerConfiguration{}
			} else {
				yyv4 := &x.Config
				yyv4.CodecDecodeSelf(d)
			}
		case "CAS":
			if r.TryDecodeAsNil() {
				x.CAS = false
			} else {
				yyv5 := &x.CAS
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*bool)(yyv5)) = r.DecodeBool()
				}
			}
		case "Region":
			if r.TryDecodeAsNil() {
				x.Region = ""
			} else {
				yyv7 := &x.Region
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*string)(yyv7)) = r.DecodeString()
				}
			}
		case "Namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				yyv9 := &x.Namespace
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*string)(yyv9)) = r.DecodeString()
				}
			}
		case "AuthToken":
			if r.TryDecodeAsNil() {
				x.AuthToken = ""
			} else {
				yyv11 := &x.AuthToken
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else {
					*((*string)(yyv11)) = r.DecodeString()
				}
			}
		case "Forwarded":
			if r.TryDecodeAsNil() {
				x.Forwarded = false
			} else {
				yyv13 := &x.Forwarded
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else {
					*((*bool)(yyv13)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *SchedulerSetConfigRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Config = SchedulerConfiguration{}
	} else {
		yyv16 := &x.Config
		yyv16.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.CAS = false
	} else {
		yyv17 := &x.CAS
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*bool)(yyv17)) = r.DecodeBool()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Region = ""
	} else {
		yyv19 := &x.Region
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Namespace = ""
	} else {
		yyv21 := &x.Namespace
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.AuthToken = ""
	} else {
		yyv23 := &x.AuthToken
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*string)(yyv23)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Forwarded = false
	} else {
		yyv25 := &x.Forwarded
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			*((*bool)(yyv25)) = r.DecodeBool()
		}
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *StreamingRpcHeader) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 1
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Method))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Method"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Method))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *StreamingRpcHeader) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *StreamingRpcHeader) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Method":
			if r.TryDecodeAsNil() {
				x.Method = ""
			} else {
				yyv4 := &x.Method
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *StreamingRpcHeader) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj6 int
	var yyb6 bool
	var yyhl6 bool = l >= 0
	yyj6++
	if yyhl6 {
		yyb6 = yyj6 > l
	} else {
		yyb6 = r.CheckBreak()
	}
	if yyb6 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Method = ""
	} else {
		yyv7 := &x.Method
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else {
			*((*string)(yyv7)) = r.DecodeString()
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *StreamingRpcAck) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(1)
			} else {
				yynn2 = 1
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem100)
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Error))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey100)
				r.EncodeString(codecSelferC_UTF8100, string("Error"))
				z.EncSendContainerState(codecSelfer_containerMapValue100)
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferC_UTF8100, string(x.Error))
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *StreamingRpcAck) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *StreamingRpcAck) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		case "Error":
			if r.TryDecodeAsNil() {
				x.Error = ""
			} else {
				yyv4 := &x.Error
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *StreamingRpcAck) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj6 int
	var yyb6 bool
	var yyhl6 bool = l >= 0
	yyj6++
	if yyhl6 {
		yyb6 = yyj6 > l
	} else {
		yyb6 = r.CheckBreak()
	}
	if yyb6 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem100)
	if r.TryDecodeAsNil() {
		x.Error = ""
	} else {
		yyv7 := &x.Error
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else {
			*((*string)(yyv7)) = r.DecodeString()
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x *StreamingRpcRegistry) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer100
	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 [0]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(0)
			} else {
				yynn2 = 0
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd100)
			}
		}
	}
}

func (x *StreamingRpcRegistry) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym1 := z.DecBinary()
	_ = yym1
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap100 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd100)
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray100 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
		}
	}
}

func (x *StreamingRpcRegistry) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys3Slc
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey100)
		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
		yys3 := string(yys3Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue100)
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x *StreamingRpcRegistry) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj4 int
	var yyb4 bool
	var yyhl4 bool = l >= 0
	for {
		yyj4++
		if yyhl4 {
			yyb4 = yyj4 > l
		} else {
			yyb4 = r.CheckBreak()
		}
		if yyb4 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem100)
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) encBitmap(v Bitmap, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeStringBytes(codecSelferC_RAW100, []byte(v))
}

func (x codecSelfer100) decBitmap(v *Bitmap, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	*v = r.DecodeBytes(*((*[]byte)(v)), false, false)
}

func (x codecSelfer100) encSlicePtrtoFieldDiff(v []*FieldDiff, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoFieldDiff(v *[]*FieldDiff, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*FieldDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*FieldDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*FieldDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = FieldDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(FieldDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = FieldDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(FieldDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *FieldDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = FieldDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(FieldDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*FieldDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encSlicePtrtoObjectDiff(v []*ObjectDiff, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoObjectDiff(v *[]*ObjectDiff, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*ObjectDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*ObjectDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*ObjectDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = ObjectDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(ObjectDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = ObjectDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ObjectDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *ObjectDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = ObjectDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ObjectDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*ObjectDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encSlicePtrtoTaskGroupDiff(v []*TaskGroupDiff, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoTaskGroupDiff(v *[]*TaskGroupDiff, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*TaskGroupDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*TaskGroupDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*TaskGroupDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = TaskGroupDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(TaskGroupDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskGroupDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskGroupDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *TaskGroupDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskGroupDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskGroupDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*TaskGroupDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encSlicePtrtoTaskDiff(v []*TaskDiff, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoTaskDiff(v *[]*TaskDiff, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*TaskDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*TaskDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*TaskDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = TaskDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(TaskDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *TaskDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*TaskDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encTaskGroupDiffs(v TaskGroupDiffs, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decTaskGroupDiffs(v *TaskGroupDiffs, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*TaskGroupDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*TaskGroupDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*TaskGroupDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = TaskGroupDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(TaskGroupDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskGroupDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskGroupDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *TaskGroupDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskGroupDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskGroupDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*TaskGroupDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encTaskDiffs(v TaskDiffs, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decTaskDiffs(v *TaskDiffs, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*TaskDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*TaskDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*TaskDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = TaskDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(TaskDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *TaskDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = TaskDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(TaskDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*TaskDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encObjectDiffs(v ObjectDiffs, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decObjectDiffs(v *ObjectDiffs, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*ObjectDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*ObjectDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*ObjectDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = ObjectDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(ObjectDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = ObjectDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ObjectDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *ObjectDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = ObjectDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ObjectDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*ObjectDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encFieldDiffs(v FieldDiffs, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decFieldDiffs(v *FieldDiffs, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*FieldDiff{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*FieldDiff, yyrl1)
				}
			} else {
				yyv1 = make([]*FieldDiff, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = FieldDiff{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(FieldDiff)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = FieldDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(FieldDiff)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *FieldDiff
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = FieldDiff{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(FieldDiff)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*FieldDiff{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encSlicePtrtoNetworkResource(v []*NetworkResource, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yym2 := z.EncBinary()
			_ = yym2
			if false {
			} else if z.HasExtensions() && z.EncExt(yyv1) {
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoNetworkResource(v *[]*NetworkResource, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*NetworkResource{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*NetworkResource, yyrl1)
				}
			} else {
				yyv1 = make([]*NetworkResource, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = NetworkResource{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(NetworkResource)
				}
				yyw2 := yyv1[yyj1]
				yym3 := z.DecBinary()
				_ = yym3
				if false {
				} else if z.HasExtensions() && z.DecExt(yyw2) {
				} else {
					z.DecFallback(yyw2, false)
				}
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = NetworkResource{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(NetworkResource)
					}
					yyw4 := yyv1[yyj1]
					yym5 := z.DecBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.DecExt(yyw4) {
					} else {
						z.DecFallback(yyw4, false)
					}
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *NetworkResource
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = NetworkResource{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(NetworkResource)
					}
					yyw6 := yyv1[yyj1]
					yym7 := z.DecBinary()
					_ = yym7
					if false {
					} else if z.HasExtensions() && z.DecExt(yyw6) {
					} else {
						z.DecFallback(yyw6, false)
					}
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*NetworkResource{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}

func (x codecSelfer100) encMapstringBitmap(v map[string]Bitmap, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeMapStart(len(v))
	for yyk1, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerMapKey100)
		yym2 := z.EncBinary()
		_ = yym2
		if false {
		} else {
			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
		}
		z.EncSendContainerState(codecSelfer_containerMapValue100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerMapEnd100)
}

func (x codecSelfer100) decMapstringBitmap(v *map[string]Bitmap, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyl1 := r.ReadMapStart()
	yybh1 := z.DecBasicHandle()
	if yyv1 == nil {
		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
		yyv1 = make(map[string]Bitmap, yyrl1)
		*v = yyv1
	}
	var yymk1 string
	var yymv1 Bitmap
	var yymg1 bool
	if yybh1.MapValueReset {
		yymg1 = true
	}
	if yyl1 > 0 {
		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
			z.DecSendContainerState(codecSelfer_containerMapKey100)
			if r.TryDecodeAsNil() {
				yymk1 = ""
			} else {
				yyv2 := &yymk1
				yym3 := z.DecBinary()
				_ = yym3
				if false {
				} else {
					*((*string)(yyv2)) = r.DecodeString()
				}
			}

			if yymg1 {
				yymv1 = yyv1[yymk1]
			} else {
				yymv1 = nil
			}
			z.DecSendContainerState(codecSelfer_containerMapValue100)
			if r.TryDecodeAsNil() {
				yymv1 = nil
			} else {
				yyv4 := &yymv1
				yyv4.CodecDecodeSelf(d)
			}

			if yyv1 != nil {
				yyv1[yymk1] = yymv1
			}
		}
	} else if yyl1 < 0 {
		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
			z.DecSendContainerState(codecSelfer_containerMapKey100)
			if r.TryDecodeAsNil() {
				yymk1 = ""
			} else {
				yyv5 := &yymk1
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*string)(yyv5)) = r.DecodeString()
				}
			}

			if yymg1 {
				yymv1 = yyv1[yymk1]
			} else {
				yymv1 = nil
			}
			z.DecSendContainerState(codecSelfer_containerMapValue100)
			if r.TryDecodeAsNil() {
				yymv1 = nil
			} else {
				yyv7 := &yymv1
				yyv7.CodecDecodeSelf(d)
			}

			if yyv1 != nil {
				yyv1[yymk1] = yymv1
			}
		}
	} // else len==0: TODO: Should we clear map entries?
	z.DecSendContainerState(codecSelfer_containerMapEnd100)
}

func (x codecSelfer100) encSlicePtrtoRaftServer(v []*RaftServer, e *codec1978.Encoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.EncodeArrayStart(len(v))
	for _, yyv1 := range v {
		z.EncSendContainerState(codecSelfer_containerArrayElem100)
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
}

func (x codecSelfer100) decSlicePtrtoRaftServer(v *[]*RaftServer, d *codec1978.Decoder) {
	var h codecSelfer100
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r

	yyv1 := *v
	yyh1, yyl1 := z.DecSliceHelperStart()
	var yyc1 bool
	_ = yyc1
	if yyl1 == 0 {
		if yyv1 == nil {
			yyv1 = []*RaftServer{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else if yyl1 > 0 {
		var yyrr1, yyrl1 int
		var yyrt1 bool
		_, _ = yyrl1, yyrt1
		yyrr1 = yyl1 // len(yyv1)
		if yyl1 > cap(yyv1) {

			yyrg1 := len(yyv1) > 0
			yyv21 := yyv1
			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
			if yyrt1 {
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*RaftServer, yyrl1)
				}
			} else {
				yyv1 = make([]*RaftServer, yyrl1)
			}
			yyc1 = true
			yyrr1 = len(yyv1)
			if yyrg1 {
				copy(yyv1, yyv21)
			}
		} else if yyl1 != len(yyv1) {
			yyv1 = yyv1[:yyl1]
			yyc1 = true
		}
		yyj1 := 0
		for ; yyj1 < yyrr1; yyj1++ {
			yyh1.ElemContainerState(yyj1)
			if r.TryDecodeAsNil() {
				if yyv1[yyj1] != nil {
					*yyv1[yyj1] = RaftServer{}
				}
			} else {
				if yyv1[yyj1] == nil {
					yyv1[yyj1] = new(RaftServer)
				}
				yyw2 := yyv1[yyj1]
				yyw2.CodecDecodeSelf(d)
			}

		}
		if yyrt1 {
			for ; yyj1 < yyl1; yyj1++ {
				yyv1 = append(yyv1, nil)
				yyh1.ElemContainerState(yyj1)
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = RaftServer{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(RaftServer)
					}
					yyw3 := yyv1[yyj1]
					yyw3.CodecDecodeSelf(d)
				}

			}
		}

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

			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil) // var yyz1 *RaftServer
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			if yyj1 < len(yyv1) {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = RaftServer{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(RaftServer)
					}
					yyw4 := yyv1[yyj1]
					yyw4.CodecDecodeSelf(d)
				}

			} else {
				z.DecSwallow()
			}

		}
		if yyj1 < len(yyv1) {
			yyv1 = yyv1[:yyj1]
			yyc1 = true
		} else if yyj1 == 0 && yyv1 == nil {
			yyv1 = []*RaftServer{}
			yyc1 = true
		}
	}
	yyh1.End()
	if yyc1 {
		*v = yyv1
	}
}