surrealpatch/sql/ast.gen.go

// Code generated by codecgen - DO NOT EDIT.

package sql

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg1_language "golang.org/x/text/language"
	"reflect"
	"runtime"
	time "time"
)

const (
	// ----- content types ----
	codecSelferCcUTF84085 = 1
	codecSelferCcRAW4085  = 0
	// ----- value types used ----
	codecSelferValueTypeArray4085 = 10
	codecSelferValueTypeMap4085   = 9
	// ----- containerStateValues ----
	codecSelferKcontainerMapKey4085    = 2
	codecSelferKcontainerMapValue4085  = 3
	codecSelferKcontainerMapEnd4085    = 4
	codecSelferKcontainerArrayElem4085 = 6
	codecSelferKcontainerArrayEnd4085  = 7
)

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

type codecSelfer4085 struct{}

func init() {
	if codec1978.GenVersion != 8 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			8, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg1_language.Tag
		var v1 time.Duration
		_, _ = v0, v1
	}
}

func (x *Query) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Statements == nil {
					r.EncodeNil()
				} else {
					x.Statements.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Statements`)
				r.WriteMapElemValue()
				if x.Statements == nil {
					r.EncodeNil()
				} else {
					x.Statements.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Query) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Query) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Statements":
			if r.TryDecodeAsNil() {
				x.Statements = nil
			} else {
				yyv4 := &x.Statements
				yyv4.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Query) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Statements = nil
	} else {
		yyv6 := &x.Statements
		yyv6.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x Statements) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encStatements((Statements)(x), e)
		}
	}
}

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

func (x *BeginStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *BeginStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *BeginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *BeginStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *CancelStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *CancelStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *CancelStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *CancelStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *CommitStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *CommitStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *CommitStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *CommitStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *UseStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *UseStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *UseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *UseStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *InfoStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *InfoStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *InfoStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *InfoStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *IfStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					x.Cond.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					x.Cond.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					x.Then.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `then`)
				r.WriteMapElemValue()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					x.Then.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Else) {
					} else {
						z.EncFallback(x.Else)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `else`)
				r.WriteMapElemValue()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Else) {
					} else {
						z.EncFallback(x.Else)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *IfStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *IfStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv4 := &x.Cond
				yyv4.CodecDecodeSelf(d)
			}
		case "then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				yyv5 := &x.Then
				yyv5.CodecDecodeSelf(d)
			}
		case "else":
			if r.TryDecodeAsNil() {
				x.Else = nil
			} else {
				yyv6 := &x.Else
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else {
					z.DecFallback(yyv6, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *IfStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv9 := &x.Cond
		yyv9.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Then = nil
	} else {
		yyv10 := &x.Then
		yyv10.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Else = nil
	} else {
		yyv11 := &x.Else
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x *LetStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *LetStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *LetStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *LetStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *ReturnStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *ReturnStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *ReturnStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *ReturnStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *LiveStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `ID`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.FB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `FB`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.FB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym16 := z.EncBinary()
				_ = yym16
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym17 := z.EncBinary()
				_ = yym17
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else {
					r.EncodeBool(bool(x.Diff))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `diff`)
				r.WriteMapElemValue()
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else {
					r.EncodeBool(bool(x.Diff))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			}
			var yyn24 bool
			if x.What == nil {
				yyn24 = true
				goto LABEL24
			}
		LABEL24:
			if yyr2 || yy2arr2 {
				if yyn24 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.What == nil {
						r.EncodeNil()
					} else {
						x.What.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `what`)
				r.WriteMapElemValue()
				if yyn24 {
					r.EncodeNil()
				} else {
					if x.What == nil {
						r.EncodeNil()
					} else {
						x.What.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym28 := z.EncBinary()
					_ = yym28
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym29 := z.EncBinary()
					_ = yym29
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *LiveStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *LiveStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "FB":
			if r.TryDecodeAsNil() {
				x.FB = ""
			} else {
				yyv6 := &x.FB
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv8 := &x.KV
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv10 := &x.NS
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*string)(yyv10)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv12 := &x.DB
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else {
					*((*string)(yyv12)) = r.DecodeString()
				}
			}
		case "diff":
			if r.TryDecodeAsNil() {
				x.Diff = false
			} else {
				yyv14 := &x.Diff
				yym15 := z.DecBinary()
				_ = yym15
				if false {
				} else {
					*((*bool)(yyv14)) = r.DecodeBool()
				}
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv16 := &x.Expr
				yyv16.CodecDecodeSelf(d)
			}
		case "what":
			if x.What == nil {
				x.What = new(Table)
			}
			if r.TryDecodeAsNil() {
				if x.What != nil {
					x.What = nil
				}
			} else {
				if x.What == nil {
					x.What = new(Table)
				}
				x.What.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv18 := &x.Cond
				yym19 := z.DecBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv18) {
				} else {
					z.DecFallback(yyv18, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *LiveStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj20 int
	var yyb20 bool
	var yyhl20 bool = l >= 0
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv21 := &x.ID
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.FB = ""
	} else {
		yyv23 := &x.FB
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else {
			*((*string)(yyv23)) = r.DecodeString()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv25 := &x.KV
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			*((*string)(yyv25)) = r.DecodeString()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv27 := &x.NS
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else {
			*((*string)(yyv27)) = r.DecodeString()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv29 := &x.DB
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else {
			*((*string)(yyv29)) = r.DecodeString()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Diff = false
	} else {
		yyv31 := &x.Diff
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else {
			*((*bool)(yyv31)) = r.DecodeBool()
		}
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv33 := &x.Expr
		yyv33.CodecDecodeSelf(d)
	}
	if x.What == nil {
		x.What = new(Table)
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.What != nil {
			x.What = nil
		}
	} else {
		if x.What == nil {
			x.What = new(Table)
		}
		x.What.CodecDecodeSelf(d)
	}
	yyj20++
	if yyhl20 {
		yyb20 = yyj20 > l
	} else {
		yyb20 = r.CheckBreak()
	}
	if yyb20 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv35 := &x.Cond
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv35) {
		} else {
			z.DecFallback(yyv35, true)
		}
	}
	for {
		yyj20++
		if yyhl20 {
			yyb20 = yyj20 > l
		} else {
			yyb20 = r.CheckBreak()
		}
		if yyb20 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj20-1, "")
	}
	r.ReadArrayEnd()
}

func (x *KillStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(5)
			} else {
				r.WriteMapStart(5)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.FB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `FB`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.FB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			var yyn15 bool
			if x.Name == nil {
				yyn15 = true
				goto LABEL15
			}
		LABEL15:
			if yyr2 || yy2arr2 {
				if yyn15 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn15 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *KillStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *KillStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "FB":
			if r.TryDecodeAsNil() {
				x.FB = ""
			} else {
				yyv4 := &x.FB
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv6 := &x.KV
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv8 := &x.NS
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv10 := &x.DB
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*string)(yyv10)) = r.DecodeString()
				}
			}
		case "name":
			if x.Name == nil {
				x.Name = new(Value)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Value)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *KillStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.FB = ""
	} else {
		yyv14 := &x.FB
		yym15 := z.DecBinary()
		_ = yym15
		if false {
		} else {
			*((*string)(yyv14)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv16 := &x.KV
		yym17 := z.DecBinary()
		_ = yym17
		if false {
		} else {
			*((*string)(yyv16)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv18 := &x.NS
		yym19 := z.DecBinary()
		_ = yym19
		if false {
		} else {
			*((*string)(yyv18)) = r.DecodeString()
		}
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv20 := &x.DB
		yym21 := z.DecBinary()
		_ = yym21
		if false {
		} else {
			*((*string)(yyv20)) = r.DecodeString()
		}
	}
	if x.Name == nil {
		x.Name = new(Value)
	}
	yyj13++
	if yyhl13 {
		yyb13 = yyj13 > l
	} else {
		yyb13 = r.CheckBreak()
	}
	if yyb13 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Value)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj13++
		if yyhl13 {
			yyb13 = yyj13 > l
		} else {
			yyb13 = r.CheckBreak()
		}
		if yyb13 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj13-1, "")
	}
	r.ReadArrayEnd()
}

func (x *SelectStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(13)
			} else {
				r.WriteMapStart(13)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `what`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Group == nil {
					r.EncodeNil()
				} else {
					x.Group.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `group`)
				r.WriteMapElemValue()
				if x.Group == nil {
					r.EncodeNil()
				} else {
					x.Group.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Order == nil {
					r.EncodeNil()
				} else {
					x.Order.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `order`)
				r.WriteMapElemValue()
				if x.Order == nil {
					r.EncodeNil()
				} else {
					x.Order.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Limit == nil {
					r.EncodeNil()
				} else {
					yym28 := z.EncBinary()
					_ = yym28
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Limit) {
					} else {
						z.EncFallback(x.Limit)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `limit`)
				r.WriteMapElemValue()
				if x.Limit == nil {
					r.EncodeNil()
				} else {
					yym29 := z.EncBinary()
					_ = yym29
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Limit) {
					} else {
						z.EncFallback(x.Limit)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Start == nil {
					r.EncodeNil()
				} else {
					yym31 := z.EncBinary()
					_ = yym31
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Start) {
					} else {
						z.EncFallback(x.Start)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `start`)
				r.WriteMapElemValue()
				if x.Start == nil {
					r.EncodeNil()
				} else {
					yym32 := z.EncBinary()
					_ = yym32
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Start) {
					} else {
						z.EncFallback(x.Start)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Version == nil {
					r.EncodeNil()
				} else {
					yym34 := z.EncBinary()
					_ = yym34
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Version) {
					} else {
						z.EncFallback(x.Version)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `version`)
				r.WriteMapElemValue()
				if x.Version == nil {
					r.EncodeNil()
				} else {
					yym35 := z.EncBinary()
					_ = yym35
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Version) {
					} else {
						z.EncFallback(x.Version)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym37 := z.EncBinary()
				_ = yym37
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym38 := z.EncBinary()
				_ = yym38
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym40 := z.EncBinary()
				_ = yym40
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym41 := z.EncBinary()
				_ = yym41
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *SelectStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *SelectStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv10 := &x.Expr
				yyv10.CodecDecodeSelf(d)
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				yyv11 := &x.What
				yyv11.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv12 := &x.Cond
				yym13 := z.DecBinary()
				_ = yym13
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv12) {
				} else {
					z.DecFallback(yyv12, true)
				}
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Group = nil
			} else {
				yyv14 := &x.Group
				yyv14.CodecDecodeSelf(d)
			}
		case "order":
			if r.TryDecodeAsNil() {
				x.Order = nil
			} else {
				yyv15 := &x.Order
				yyv15.CodecDecodeSelf(d)
			}
		case "limit":
			if r.TryDecodeAsNil() {
				x.Limit = nil
			} else {
				yyv16 := &x.Limit
				yym17 := z.DecBinary()
				_ = yym17
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv16) {
				} else {
					z.DecFallback(yyv16, true)
				}
			}
		case "start":
			if r.TryDecodeAsNil() {
				x.Start = nil
			} else {
				yyv18 := &x.Start
				yym19 := z.DecBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv18) {
				} else {
					z.DecFallback(yyv18, true)
				}
			}
		case "version":
			if r.TryDecodeAsNil() {
				x.Version = nil
			} else {
				yyv20 := &x.Version
				yym21 := z.DecBinary()
				_ = yym21
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv20) {
				} else {
					z.DecFallback(yyv20, true)
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv22 := &x.Timeout
				yym23 := z.DecBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv22) {
				} else {
					*((*int64)(yyv22)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv24 := &x.Parallel
				yym25 := z.DecBinary()
				_ = yym25
				if false {
				} else {
					*((*int)(yyv24)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *SelectStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj26 int
	var yyb26 bool
	var yyhl26 bool = l >= 0
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv27 := &x.KV
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else {
			*((*string)(yyv27)) = r.DecodeString()
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv29 := &x.NS
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else {
			*((*string)(yyv29)) = r.DecodeString()
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv31 := &x.DB
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else {
			*((*string)(yyv31)) = r.DecodeString()
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv33 := &x.Expr
		yyv33.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		yyv34 := &x.What
		yyv34.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv35 := &x.Cond
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv35) {
		} else {
			z.DecFallback(yyv35, true)
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Group = nil
	} else {
		yyv37 := &x.Group
		yyv37.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Order = nil
	} else {
		yyv38 := &x.Order
		yyv38.CodecDecodeSelf(d)
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Limit = nil
	} else {
		yyv39 := &x.Limit
		yym40 := z.DecBinary()
		_ = yym40
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv39) {
		} else {
			z.DecFallback(yyv39, true)
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Start = nil
	} else {
		yyv41 := &x.Start
		yym42 := z.DecBinary()
		_ = yym42
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv41) {
		} else {
			z.DecFallback(yyv41, true)
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Version = nil
	} else {
		yyv43 := &x.Version
		yym44 := z.DecBinary()
		_ = yym44
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv43) {
		} else {
			z.DecFallback(yyv43, true)
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv45 := &x.Timeout
		yym46 := z.DecBinary()
		_ = yym46
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv45) {
		} else {
			*((*int64)(yyv45)) = int64(r.DecodeInt(64))
		}
	}
	yyj26++
	if yyhl26 {
		yyb26 = yyj26 > l
	} else {
		yyb26 = r.CheckBreak()
	}
	if yyb26 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv47 := &x.Parallel
		yym48 := z.DecBinary()
		_ = yym48
		if false {
		} else {
			*((*int)(yyv47)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj26++
		if yyhl26 {
			yyb26 = yyj26 > l
		} else {
			yyb26 = r.CheckBreak()
		}
		if yyb26 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj26-1, "")
	}
	r.ReadArrayEnd()
}

func (x *CreateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `what`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym19 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym19 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym20 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym20 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *CreateStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *CreateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				yyv10 := &x.What
				yyv10.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv11 := &x.Data
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv11) {
				} else {
					z.DecFallback(yyv11, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv13 := &x.Echo
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else if yym14 {
					z.DecBinaryUnmarshal(yyv13)
				} else {
					*((*int16)(yyv13)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv15 := &x.Timeout
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv15) {
				} else {
					*((*int64)(yyv15)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv17 := &x.Parallel
				yym18 := z.DecBinary()
				_ = yym18
				if false {
				} else {
					*((*int)(yyv17)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *CreateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj19 int
	var yyb19 bool
	var yyhl19 bool = l >= 0
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv20 := &x.KV
		yym21 := z.DecBinary()
		_ = yym21
		if false {
		} else {
			*((*string)(yyv20)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv22 := &x.NS
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*string)(yyv22)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv24 := &x.DB
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*string)(yyv24)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		yyv26 := &x.What
		yyv26.CodecDecodeSelf(d)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv27 := &x.Data
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv27) {
		} else {
			z.DecFallback(yyv27, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv29 := &x.Echo
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv29) {
		} else if yym30 {
			z.DecBinaryUnmarshal(yyv29)
		} else {
			*((*int16)(yyv29)) = int16(r.DecodeInt(16))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv31 := &x.Timeout
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv33 := &x.Parallel
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else {
			*((*int)(yyv33)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj19++
		if yyhl19 {
			yyb19 = yyj19 > l
		} else {
			yyb19 = r.CheckBreak()
		}
		if yyb19 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj19-1, "")
	}
	r.ReadArrayEnd()
}

func (x *UpdateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `what`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym22 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym22 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym23 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym23 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym28 := z.EncBinary()
				_ = yym28
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym29 := z.EncBinary()
				_ = yym29
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *UpdateStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *UpdateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				yyv10 := &x.What
				yyv10.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv11 := &x.Data
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv11) {
				} else {
					z.DecFallback(yyv11, true)
				}
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv13 := &x.Cond
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else {
					z.DecFallback(yyv13, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv15 := &x.Echo
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv15) {
				} else if yym16 {
					z.DecBinaryUnmarshal(yyv15)
				} else {
					*((*int16)(yyv15)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv17 := &x.Timeout
				yym18 := z.DecBinary()
				_ = yym18
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv17) {
				} else {
					*((*int64)(yyv17)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv19 := &x.Parallel
				yym20 := z.DecBinary()
				_ = yym20
				if false {
				} else {
					*((*int)(yyv19)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *UpdateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj21 int
	var yyb21 bool
	var yyhl21 bool = l >= 0
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv22 := &x.KV
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*string)(yyv22)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv24 := &x.NS
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*string)(yyv24)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv26 := &x.DB
		yym27 := z.DecBinary()
		_ = yym27
		if false {
		} else {
			*((*string)(yyv26)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		yyv28 := &x.What
		yyv28.CodecDecodeSelf(d)
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv29 := &x.Data
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv29) {
		} else {
			z.DecFallback(yyv29, true)
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv31 := &x.Cond
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			z.DecFallback(yyv31, true)
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv33 := &x.Echo
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv33) {
		} else if yym34 {
			z.DecBinaryUnmarshal(yyv33)
		} else {
			*((*int16)(yyv33)) = int16(r.DecodeInt(16))
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv35 := &x.Timeout
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv35) {
		} else {
			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv37 := &x.Parallel
		yym38 := z.DecBinary()
		_ = yym38
		if false {
		} else {
			*((*int)(yyv37)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj21++
		if yyhl21 {
			yyb21 = yyj21 > l
		} else {
			yyb21 = r.CheckBreak()
		}
		if yyb21 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj21-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DeleteStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeBool(bool(x.Hard))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `hard`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeBool(bool(x.Hard))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `what`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym22 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym22 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym23 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym23 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym28 := z.EncBinary()
				_ = yym28
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym29 := z.EncBinary()
				_ = yym29
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DeleteStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DeleteStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "hard":
			if r.TryDecodeAsNil() {
				x.Hard = false
			} else {
				yyv10 := &x.Hard
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*bool)(yyv10)) = r.DecodeBool()
				}
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				yyv12 := &x.What
				yyv12.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv13 := &x.Cond
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else {
					z.DecFallback(yyv13, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv15 := &x.Echo
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv15) {
				} else if yym16 {
					z.DecBinaryUnmarshal(yyv15)
				} else {
					*((*int16)(yyv15)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv17 := &x.Timeout
				yym18 := z.DecBinary()
				_ = yym18
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv17) {
				} else {
					*((*int64)(yyv17)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv19 := &x.Parallel
				yym20 := z.DecBinary()
				_ = yym20
				if false {
				} else {
					*((*int)(yyv19)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DeleteStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj21 int
	var yyb21 bool
	var yyhl21 bool = l >= 0
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv22 := &x.KV
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*string)(yyv22)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv24 := &x.NS
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*string)(yyv24)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv26 := &x.DB
		yym27 := z.DecBinary()
		_ = yym27
		if false {
		} else {
			*((*string)(yyv26)) = r.DecodeString()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Hard = false
	} else {
		yyv28 := &x.Hard
		yym29 := z.DecBinary()
		_ = yym29
		if false {
		} else {
			*((*bool)(yyv28)) = r.DecodeBool()
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		yyv30 := &x.What
		yyv30.CodecDecodeSelf(d)
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv31 := &x.Cond
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			z.DecFallback(yyv31, true)
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv33 := &x.Echo
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv33) {
		} else if yym34 {
			z.DecBinaryUnmarshal(yyv33)
		} else {
			*((*int16)(yyv33)) = int16(r.DecodeInt(16))
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv35 := &x.Timeout
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv35) {
		} else {
			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
		}
	}
	yyj21++
	if yyhl21 {
		yyb21 = yyj21 > l
	} else {
		yyb21 = r.CheckBreak()
	}
	if yyb21 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv37 := &x.Parallel
		yym38 := z.DecBinary()
		_ = yym38
		if false {
		} else {
			*((*int)(yyv37)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj21++
		if yyhl21 {
			yyb21 = yyj21 > l
		} else {
			yyb21 = r.CheckBreak()
		}
		if yyb21 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj21-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RelateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(11)
			} else {
				r.WriteMapStart(11)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Type == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Type) {
					} else {
						z.EncFallback(x.Type)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `type`)
				r.WriteMapElemValue()
				if x.Type == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Type) {
					} else {
						z.EncFallback(x.Type)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.From == nil {
					r.EncodeNil()
				} else {
					x.From.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `from`)
				r.WriteMapElemValue()
				if x.From == nil {
					r.EncodeNil()
				} else {
					x.From.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.With == nil {
					r.EncodeNil()
				} else {
					x.With.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `with`)
				r.WriteMapElemValue()
				if x.With == nil {
					r.EncodeNil()
				} else {
					x.With.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym22 := z.EncBinary()
					_ = yym22
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym23 := z.EncBinary()
					_ = yym23
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `uniq`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym28 := z.EncBinary()
				_ = yym28
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym28 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym28 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym29 := z.EncBinary()
				_ = yym29
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym29 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym29 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym31 := z.EncBinary()
				_ = yym31
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym32 := z.EncBinary()
				_ = yym32
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym34 := z.EncBinary()
				_ = yym34
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym35 := z.EncBinary()
				_ = yym35
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RelateStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RelateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = nil
			} else {
				yyv10 := &x.Type
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv10) {
				} else {
					z.DecFallback(yyv10, true)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv12 := &x.From
				yyv12.CodecDecodeSelf(d)
			}
		case "with":
			if r.TryDecodeAsNil() {
				x.With = nil
			} else {
				yyv13 := &x.With
				yyv13.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv14 := &x.Data
				yym15 := z.DecBinary()
				_ = yym15
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv14) {
				} else {
					z.DecFallback(yyv14, true)
				}
			}
		case "uniq":
			if r.TryDecodeAsNil() {
				x.Uniq = false
			} else {
				yyv16 := &x.Uniq
				yym17 := z.DecBinary()
				_ = yym17
				if false {
				} else {
					*((*bool)(yyv16)) = r.DecodeBool()
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv18 := &x.Echo
				yym19 := z.DecBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv18) {
				} else if yym19 {
					z.DecBinaryUnmarshal(yyv18)
				} else {
					*((*int16)(yyv18)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv20 := &x.Timeout
				yym21 := z.DecBinary()
				_ = yym21
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv20) {
				} else {
					*((*int64)(yyv20)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv22 := &x.Parallel
				yym23 := z.DecBinary()
				_ = yym23
				if false {
				} else {
					*((*int)(yyv22)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RelateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj24 int
	var yyb24 bool
	var yyhl24 bool = l >= 0
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv25 := &x.KV
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else {
			*((*string)(yyv25)) = r.DecodeString()
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv27 := &x.NS
		yym28 := z.DecBinary()
		_ = yym28
		if false {
		} else {
			*((*string)(yyv27)) = r.DecodeString()
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv29 := &x.DB
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else {
			*((*string)(yyv29)) = r.DecodeString()
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = nil
	} else {
		yyv31 := &x.Type
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			z.DecFallback(yyv31, true)
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv33 := &x.From
		yyv33.CodecDecodeSelf(d)
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.With = nil
	} else {
		yyv34 := &x.With
		yyv34.CodecDecodeSelf(d)
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv35 := &x.Data
		yym36 := z.DecBinary()
		_ = yym36
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv35) {
		} else {
			z.DecFallback(yyv35, true)
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Uniq = false
	} else {
		yyv37 := &x.Uniq
		yym38 := z.DecBinary()
		_ = yym38
		if false {
		} else {
			*((*bool)(yyv37)) = r.DecodeBool()
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv39 := &x.Echo
		yym40 := z.DecBinary()
		_ = yym40
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv39) {
		} else if yym40 {
			z.DecBinaryUnmarshal(yyv39)
		} else {
			*((*int16)(yyv39)) = int16(r.DecodeInt(16))
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv41 := &x.Timeout
		yym42 := z.DecBinary()
		_ = yym42
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv41) {
		} else {
			*((*int64)(yyv41)) = int64(r.DecodeInt(64))
		}
	}
	yyj24++
	if yyhl24 {
		yyb24 = yyj24 > l
	} else {
		yyb24 = r.CheckBreak()
	}
	if yyb24 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv43 := &x.Parallel
		yym44 := z.DecBinary()
		_ = yym44
		if false {
		} else {
			*((*int)(yyv43)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj24++
		if yyhl24 {
			yyb24 = yyj24 > l
		} else {
			yyb24 = r.CheckBreak()
		}
		if yyb24 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj24-1, "")
	}
	r.ReadArrayEnd()
}

func (x *InsertStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			var yyn15 bool
			if x.Into == nil {
				yyn15 = true
				goto LABEL15
			}
		LABEL15:
			if yyr2 || yy2arr2 {
				if yyn15 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `into`)
				r.WriteMapElemValue()
				if yyn15 {
					r.EncodeNil()
				} else {
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym19 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym19 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym20 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym20 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *InsertStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *InsertStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv10 := &x.Data
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv10) {
				} else {
					z.DecFallback(yyv10, true)
				}
			}
		case "into":
			if x.Into == nil {
				x.Into = new(Table)
			}
			if r.TryDecodeAsNil() {
				if x.Into != nil {
					x.Into = nil
				}
			} else {
				if x.Into == nil {
					x.Into = new(Table)
				}
				x.Into.CodecDecodeSelf(d)
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv13 := &x.Echo
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else if yym14 {
					z.DecBinaryUnmarshal(yyv13)
				} else {
					*((*int16)(yyv13)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv15 := &x.Timeout
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv15) {
				} else {
					*((*int64)(yyv15)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv17 := &x.Parallel
				yym18 := z.DecBinary()
				_ = yym18
				if false {
				} else {
					*((*int)(yyv17)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *InsertStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj19 int
	var yyb19 bool
	var yyhl19 bool = l >= 0
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv20 := &x.KV
		yym21 := z.DecBinary()
		_ = yym21
		if false {
		} else {
			*((*string)(yyv20)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv22 := &x.NS
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*string)(yyv22)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv24 := &x.DB
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*string)(yyv24)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv26 := &x.Data
		yym27 := z.DecBinary()
		_ = yym27
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv26) {
		} else {
			z.DecFallback(yyv26, true)
		}
	}
	if x.Into == nil {
		x.Into = new(Table)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Into != nil {
			x.Into = nil
		}
	} else {
		if x.Into == nil {
			x.Into = new(Table)
		}
		x.Into.CodecDecodeSelf(d)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv29 := &x.Echo
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv29) {
		} else if yym30 {
			z.DecBinaryUnmarshal(yyv29)
		} else {
			*((*int16)(yyv29)) = int16(r.DecodeInt(16))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv31 := &x.Timeout
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv33 := &x.Parallel
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else {
			*((*int)(yyv33)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj19++
		if yyhl19 {
			yyb19 = yyj19 > l
		} else {
			yyb19 = r.CheckBreak()
		}
		if yyb19 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj19-1, "")
	}
	r.ReadArrayEnd()
}

func (x *UpsertStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `KV`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `NS`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `DB`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			var yyn15 bool
			if x.Into == nil {
				yyn15 = true
				goto LABEL15
			}
		LABEL15:
			if yyr2 || yy2arr2 {
				if yyn15 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `into`)
				r.WriteMapElemValue()
				if yyn15 {
					r.EncodeNil()
				} else {
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym19 := z.EncBinary()
				_ = yym19
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym19 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym19 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `echo`)
				r.WriteMapElemValue()
				yym20 := z.EncBinary()
				_ = yym20
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Echo) {
				} else if yym20 {
					z.EncBinaryMarshal(x.Echo)
				} else if !yym20 {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym22 := z.EncBinary()
				_ = yym22
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `timeout`)
				r.WriteMapElemValue()
				yym23 := z.EncBinary()
				_ = yym23
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym25 := z.EncBinary()
				_ = yym25
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `parallel`)
				r.WriteMapElemValue()
				yym26 := z.EncBinary()
				_ = yym26
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *UpsertStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *UpsertStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				yyv4 := &x.KV
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				yyv6 := &x.NS
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				yyv8 := &x.DB
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv10 := &x.Data
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv10) {
				} else {
					z.DecFallback(yyv10, true)
				}
			}
		case "into":
			if x.Into == nil {
				x.Into = new(Table)
			}
			if r.TryDecodeAsNil() {
				if x.Into != nil {
					x.Into = nil
				}
			} else {
				if x.Into == nil {
					x.Into = new(Table)
				}
				x.Into.CodecDecodeSelf(d)
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				yyv13 := &x.Echo
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else if yym14 {
					z.DecBinaryUnmarshal(yyv13)
				} else {
					*((*int16)(yyv13)) = int16(r.DecodeInt(16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				yyv15 := &x.Timeout
				yym16 := z.DecBinary()
				_ = yym16
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv15) {
				} else {
					*((*int64)(yyv15)) = int64(r.DecodeInt(64))
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				yyv17 := &x.Parallel
				yym18 := z.DecBinary()
				_ = yym18
				if false {
				} else {
					*((*int)(yyv17)) = int(r.DecodeInt(codecSelferBitsize4085))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *UpsertStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj19 int
	var yyb19 bool
	var yyhl19 bool = l >= 0
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		yyv20 := &x.KV
		yym21 := z.DecBinary()
		_ = yym21
		if false {
		} else {
			*((*string)(yyv20)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		yyv22 := &x.NS
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*string)(yyv22)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		yyv24 := &x.DB
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*string)(yyv24)) = r.DecodeString()
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv26 := &x.Data
		yym27 := z.DecBinary()
		_ = yym27
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv26) {
		} else {
			z.DecFallback(yyv26, true)
		}
	}
	if x.Into == nil {
		x.Into = new(Table)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Into != nil {
			x.Into = nil
		}
	} else {
		if x.Into == nil {
			x.Into = new(Table)
		}
		x.Into.CodecDecodeSelf(d)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		yyv29 := &x.Echo
		yym30 := z.DecBinary()
		_ = yym30
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv29) {
		} else if yym30 {
			z.DecBinaryUnmarshal(yyv29)
		} else {
			*((*int16)(yyv29)) = int16(r.DecodeInt(16))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		yyv31 := &x.Timeout
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		yyv33 := &x.Parallel
		yym34 := z.DecBinary()
		_ = yym34
		if false {
		} else {
			*((*int)(yyv33)) = int(r.DecodeInt(codecSelferBitsize4085))
		}
	}
	for {
		yyj19++
		if yyhl19 {
			yyb19 = yyj19 > l
		} else {
			yyb19 = r.CheckBreak()
		}
		if yyb19 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj19-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineNamespaceStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineNamespaceStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineNamespaceStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineNamespaceStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveNamespaceStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveNamespaceStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveNamespaceStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveNamespaceStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineDatabaseStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineDatabaseStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineDatabaseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineDatabaseStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveDatabaseStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveDatabaseStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveDatabaseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveDatabaseStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineLoginStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym4 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym4 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `kind`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym5 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym5 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			}
			var yyn6 bool
			if x.User == nil {
				yyn6 = true
				goto LABEL6
			}
		LABEL6:
			if yyr2 || yy2arr2 {
				if yyn6 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.User == nil {
						r.EncodeNil()
					} else {
						x.User.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `user`)
				r.WriteMapElemValue()
				if yyn6 {
					r.EncodeNil()
				} else {
					if x.User == nil {
						r.EncodeNil()
					} else {
						x.User.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Pass == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Pass))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `pass`)
				r.WriteMapElemValue()
				if x.Pass == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Pass))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineLoginStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineLoginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				yyv4 := &x.Kind
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else if yym5 {
					z.DecBinaryUnmarshal(yyv4)
				} else {
					*((*int16)(yyv4)) = int16(r.DecodeInt(16))
				}
			}
		case "user":
			if x.User == nil {
				x.User = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.User != nil {
					x.User = nil
				}
			} else {
				if x.User == nil {
					x.User = new(Ident)
				}
				x.User.CodecDecodeSelf(d)
			}
		case "pass":
			if r.TryDecodeAsNil() {
				x.Pass = nil
			} else {
				yyv7 := &x.Pass
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*yyv7 = r.DecodeBytes(*(*[]byte)(yyv7), false)
				}
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				yyv9 := &x.Code
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*yyv9 = r.DecodeBytes(*(*[]byte)(yyv9), false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineLoginStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = 0
	} else {
		yyv12 := &x.Kind
		yym13 := z.DecBinary()
		_ = yym13
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv12) {
		} else if yym13 {
			z.DecBinaryUnmarshal(yyv12)
		} else {
			*((*int16)(yyv12)) = int16(r.DecodeInt(16))
		}
	}
	if x.User == nil {
		x.User = new(Ident)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.User != nil {
			x.User = nil
		}
	} else {
		if x.User == nil {
			x.User = new(Ident)
		}
		x.User.CodecDecodeSelf(d)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Pass = nil
	} else {
		yyv15 := &x.Pass
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*yyv15 = r.DecodeBytes(*(*[]byte)(yyv15), false)
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Code = nil
	} else {
		yyv17 := &x.Code
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*yyv17 = r.DecodeBytes(*(*[]byte)(yyv17), false)
		}
	}
	for {
		yyj11++
		if yyhl11 {
			yyb11 = yyj11 > l
		} else {
			yyb11 = r.CheckBreak()
		}
		if yyb11 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj11-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveLoginStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym4 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym4 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `kind`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym5 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym5 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			}
			var yyn6 bool
			if x.User == nil {
				yyn6 = true
				goto LABEL6
			}
		LABEL6:
			if yyr2 || yy2arr2 {
				if yyn6 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.User == nil {
						r.EncodeNil()
					} else {
						x.User.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `user`)
				r.WriteMapElemValue()
				if yyn6 {
					r.EncodeNil()
				} else {
					if x.User == nil {
						r.EncodeNil()
					} else {
						x.User.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveLoginStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveLoginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				yyv4 := &x.Kind
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else if yym5 {
					z.DecBinaryUnmarshal(yyv4)
				} else {
					*((*int16)(yyv4)) = int16(r.DecodeInt(16))
				}
			}
		case "user":
			if x.User == nil {
				x.User = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.User != nil {
					x.User = nil
				}
			} else {
				if x.User == nil {
					x.User = new(Ident)
				}
				x.User.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveLoginStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj7 int
	var yyb7 bool
	var yyhl7 bool = l >= 0
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = 0
	} else {
		yyv8 := &x.Kind
		yym9 := z.DecBinary()
		_ = yym9
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv8) {
		} else if yym9 {
			z.DecBinaryUnmarshal(yyv8)
		} else {
			*((*int16)(yyv8)) = int16(r.DecodeInt(16))
		}
	}
	if x.User == nil {
		x.User = new(Ident)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.User != nil {
			x.User = nil
		}
	} else {
		if x.User == nil {
			x.User = new(Ident)
		}
		x.User.CodecDecodeSelf(d)
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineTokenStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym4 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym4 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `kind`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym5 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym5 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			}
			var yyn6 bool
			if x.Name == nil {
				yyn6 = true
				goto LABEL6
			}
		LABEL6:
			if yyr2 || yy2arr2 {
				if yyn6 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn6 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Type))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `type`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Type))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineTokenStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineTokenStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				yyv4 := &x.Kind
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else if yym5 {
					z.DecBinaryUnmarshal(yyv4)
				} else {
					*((*int16)(yyv4)) = int16(r.DecodeInt(16))
				}
			}
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv7 := &x.Type
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*string)(yyv7)) = r.DecodeString()
				}
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				yyv9 := &x.Code
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*yyv9 = r.DecodeBytes(*(*[]byte)(yyv9), false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineTokenStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = 0
	} else {
		yyv12 := &x.Kind
		yym13 := z.DecBinary()
		_ = yym13
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv12) {
		} else if yym13 {
			z.DecBinaryUnmarshal(yyv12)
		} else {
			*((*int16)(yyv12)) = int16(r.DecodeInt(16))
		}
	}
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv15 := &x.Type
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Code = nil
	} else {
		yyv17 := &x.Code
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*yyv17 = r.DecodeBytes(*(*[]byte)(yyv17), false)
		}
	}
	for {
		yyj11++
		if yyhl11 {
			yyb11 = yyj11 > l
		} else {
			yyb11 = r.CheckBreak()
		}
		if yyb11 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj11-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveTokenStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym4 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym4 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `kind`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Kind) {
				} else if yym5 {
					z.EncBinaryMarshal(x.Kind)
				} else if !yym5 {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			}
			var yyn6 bool
			if x.Name == nil {
				yyn6 = true
				goto LABEL6
			}
		LABEL6:
			if yyr2 || yy2arr2 {
				if yyn6 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn6 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveTokenStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveTokenStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				yyv4 := &x.Kind
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else if yym5 {
					z.DecBinaryUnmarshal(yyv4)
				} else {
					*((*int16)(yyv4)) = int16(r.DecodeInt(16))
				}
			}
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveTokenStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj7 int
	var yyb7 bool
	var yyhl7 bool = l >= 0
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = 0
	} else {
		yyv8 := &x.Kind
		yym9 := z.DecBinary()
		_ = yym9
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv8) {
		} else if yym9 {
			z.DecBinaryUnmarshal(yyv8)
		} else {
			*((*int16)(yyv8)) = int16(r.DecodeInt(16))
		}
	}
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineScopeStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(6)
			} else {
				r.WriteMapStart(6)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Time) {
				} else {
					r.EncodeInt(int64(x.Time))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `time`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Time) {
				} else {
					r.EncodeInt(int64(x.Time))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW4085, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Signup == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Signup) {
					} else {
						z.EncFallback(x.Signup)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `signup`)
				r.WriteMapElemValue()
				if x.Signup == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Signup) {
					} else {
						z.EncFallback(x.Signup)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Signin == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Signin) {
					} else {
						z.EncFallback(x.Signin)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `signin`)
				r.WriteMapElemValue()
				if x.Signin == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Signin) {
					} else {
						z.EncFallback(x.Signin)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Connect == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Connect) {
					} else {
						z.EncFallback(x.Connect)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `connect`)
				r.WriteMapElemValue()
				if x.Connect == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Connect) {
					} else {
						z.EncFallback(x.Connect)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineScopeStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineScopeStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "time":
			if r.TryDecodeAsNil() {
				x.Time = 0
			} else {
				yyv5 := &x.Time
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv5) {
				} else {
					*((*int64)(yyv5)) = int64(r.DecodeInt(64))
				}
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				yyv7 := &x.Code
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*yyv7 = r.DecodeBytes(*(*[]byte)(yyv7), false)
				}
			}
		case "signup":
			if r.TryDecodeAsNil() {
				x.Signup = nil
			} else {
				yyv9 := &x.Signup
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv9) {
				} else {
					z.DecFallback(yyv9, true)
				}
			}
		case "signin":
			if r.TryDecodeAsNil() {
				x.Signin = nil
			} else {
				yyv11 := &x.Signin
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv11) {
				} else {
					z.DecFallback(yyv11, true)
				}
			}
		case "connect":
			if r.TryDecodeAsNil() {
				x.Connect = nil
			} else {
				yyv13 := &x.Connect
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else {
					z.DecFallback(yyv13, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineScopeStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Time = 0
	} else {
		yyv17 := &x.Time
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv17) {
		} else {
			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Code = nil
	} else {
		yyv19 := &x.Code
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*yyv19 = r.DecodeBytes(*(*[]byte)(yyv19), false)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Signup = nil
	} else {
		yyv21 := &x.Signup
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv21) {
		} else {
			z.DecFallback(yyv21, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Signin = nil
	} else {
		yyv23 := &x.Signin
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv23) {
		} else {
			z.DecFallback(yyv23, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Connect = nil
	} else {
		yyv25 := &x.Connect
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv25) {
		} else {
			z.DecFallback(yyv25, true)
		}
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveScopeStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveScopeStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveScopeStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveScopeStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineTableStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeBool(bool(x.Full))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `full`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeBool(bool(x.Full))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeBool(bool(x.Drop))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `drop`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeBool(bool(x.Drop))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeBool(bool(x.Lock))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `lock`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeBool(bool(x.Lock))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.From == nil {
					r.EncodeNil()
				} else {
					x.From.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `from`)
				r.WriteMapElemValue()
				if x.From == nil {
					r.EncodeNil()
				} else {
					x.From.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym22 := z.EncBinary()
					_ = yym22
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym23 := z.EncBinary()
					_ = yym23
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Group == nil {
					r.EncodeNil()
				} else {
					x.Group.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `group`)
				r.WriteMapElemValue()
				if x.Group == nil {
					r.EncodeNil()
				} else {
					x.Group.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					yym28 := z.EncBinary()
					_ = yym28
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Perms) {
					} else {
						z.EncFallback(x.Perms)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `perms`)
				r.WriteMapElemValue()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					yym29 := z.EncBinary()
					_ = yym29
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Perms) {
					} else {
						z.EncFallback(x.Perms)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineTableStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineTableStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "full":
			if r.TryDecodeAsNil() {
				x.Full = false
			} else {
				yyv5 := &x.Full
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*bool)(yyv5)) = r.DecodeBool()
				}
			}
		case "drop":
			if r.TryDecodeAsNil() {
				x.Drop = false
			} else {
				yyv7 := &x.Drop
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*bool)(yyv7)) = r.DecodeBool()
				}
			}
		case "lock":
			if r.TryDecodeAsNil() {
				x.Lock = false
			} else {
				yyv9 := &x.Lock
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*bool)(yyv9)) = r.DecodeBool()
				}
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv11 := &x.Expr
				yyv11.CodecDecodeSelf(d)
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				yyv12 := &x.From
				yyv12.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv13 := &x.Cond
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else {
					z.DecFallback(yyv13, true)
				}
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Group = nil
			} else {
				yyv15 := &x.Group
				yyv15.CodecDecodeSelf(d)
			}
		case "perms":
			if r.TryDecodeAsNil() {
				x.Perms = nil
			} else {
				yyv16 := &x.Perms
				yym17 := z.DecBinary()
				_ = yym17
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv16) {
				} else {
					z.DecFallback(yyv16, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineTableStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj18 int
	var yyb18 bool
	var yyhl18 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Full = false
	} else {
		yyv20 := &x.Full
		yym21 := z.DecBinary()
		_ = yym21
		if false {
		} else {
			*((*bool)(yyv20)) = r.DecodeBool()
		}
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Drop = false
	} else {
		yyv22 := &x.Drop
		yym23 := z.DecBinary()
		_ = yym23
		if false {
		} else {
			*((*bool)(yyv22)) = r.DecodeBool()
		}
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Lock = false
	} else {
		yyv24 := &x.Lock
		yym25 := z.DecBinary()
		_ = yym25
		if false {
		} else {
			*((*bool)(yyv24)) = r.DecodeBool()
		}
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv26 := &x.Expr
		yyv26.CodecDecodeSelf(d)
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		yyv27 := &x.From
		yyv27.CodecDecodeSelf(d)
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv28 := &x.Cond
		yym29 := z.DecBinary()
		_ = yym29
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv28) {
		} else {
			z.DecFallback(yyv28, true)
		}
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Group = nil
	} else {
		yyv30 := &x.Group
		yyv30.CodecDecodeSelf(d)
	}
	yyj18++
	if yyhl18 {
		yyb18 = yyj18 > l
	} else {
		yyb18 = r.CheckBreak()
	}
	if yyb18 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Perms = nil
	} else {
		yyv31 := &x.Perms
		yym32 := z.DecBinary()
		_ = yym32
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv31) {
		} else {
			z.DecFallback(yyv31, true)
		}
	}
	for {
		yyj18++
		if yyhl18 {
			yyb18 = yyj18 > l
		} else {
			yyb18 = r.CheckBreak()
		}
		if yyb18 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj18-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveTableStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveTableStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveTableStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveTableStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineEventStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.When == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else if z.HasExtensions() && z.EncExt(x.When) {
					} else {
						z.EncFallback(x.When)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `when`)
				r.WriteMapElemValue()
				if x.When == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else if z.HasExtensions() && z.EncExt(x.When) {
					} else {
						z.EncFallback(x.When)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Then) {
					} else {
						z.EncFallback(x.Then)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `then`)
				r.WriteMapElemValue()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Then) {
					} else {
						z.EncFallback(x.Then)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineEventStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineEventStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "when":
			if r.TryDecodeAsNil() {
				x.When = nil
			} else {
				yyv5 := &x.When
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv5) {
				} else {
					z.DecFallback(yyv5, true)
				}
			}
		case "then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				yyv7 := &x.Then
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv7) {
				} else {
					z.DecFallback(yyv7, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineEventStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj9 int
	var yyb9 bool
	var yyhl9 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.When = nil
	} else {
		yyv11 := &x.When
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Then = nil
	} else {
		yyv13 := &x.Then
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv13) {
		} else {
			z.DecFallback(yyv13, true)
		}
	}
	for {
		yyj9++
		if yyhl9 {
			yyb9 = yyj9 > l
		} else {
			yyb9 = r.CheckBreak()
		}
		if yyb9 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj9-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveEventStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveEventStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveEventStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveEventStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineFieldStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(6)
			} else {
				r.WriteMapStart(6)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Perms) {
					} else {
						z.EncFallback(x.Perms)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `perms`)
				r.WriteMapElemValue()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Perms) {
					} else {
						z.EncFallback(x.Perms)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Type))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `type`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Type))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `kind`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Kind))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Value == nil {
					r.EncodeNil()
				} else {
					yym16 := z.EncBinary()
					_ = yym16
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Value) {
					} else {
						z.EncFallback(x.Value)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `value`)
				r.WriteMapElemValue()
				if x.Value == nil {
					r.EncodeNil()
				} else {
					yym17 := z.EncBinary()
					_ = yym17
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Value) {
					} else {
						z.EncFallback(x.Value)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Assert == nil {
					r.EncodeNil()
				} else {
					yym19 := z.EncBinary()
					_ = yym19
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Assert) {
					} else {
						z.EncFallback(x.Assert)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `assert`)
				r.WriteMapElemValue()
				if x.Assert == nil {
					r.EncodeNil()
				} else {
					yym20 := z.EncBinary()
					_ = yym20
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Assert) {
					} else {
						z.EncFallback(x.Assert)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineFieldStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineFieldStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "perms":
			if r.TryDecodeAsNil() {
				x.Perms = nil
			} else {
				yyv5 := &x.Perms
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv5) {
				} else {
					z.DecFallback(yyv5, true)
				}
			}
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				yyv7 := &x.Type
				yym8 := z.DecBinary()
				_ = yym8
				if false {
				} else {
					*((*string)(yyv7)) = r.DecodeString()
				}
			}
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				yyv9 := &x.Kind
				yym10 := z.DecBinary()
				_ = yym10
				if false {
				} else {
					*((*string)(yyv9)) = r.DecodeString()
				}
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.Value = nil
			} else {
				yyv11 := &x.Value
				yym12 := z.DecBinary()
				_ = yym12
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv11) {
				} else {
					z.DecFallback(yyv11, true)
				}
			}
		case "assert":
			if r.TryDecodeAsNil() {
				x.Assert = nil
			} else {
				yyv13 := &x.Assert
				yym14 := z.DecBinary()
				_ = yym14
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv13) {
				} else {
					z.DecFallback(yyv13, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineFieldStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Perms = nil
	} else {
		yyv17 := &x.Perms
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv17) {
		} else {
			z.DecFallback(yyv17, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		yyv19 := &x.Type
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*string)(yyv19)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		yyv21 := &x.Kind
		yym22 := z.DecBinary()
		_ = yym22
		if false {
		} else {
			*((*string)(yyv21)) = r.DecodeString()
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Value = nil
	} else {
		yyv23 := &x.Value
		yym24 := z.DecBinary()
		_ = yym24
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv23) {
		} else {
			z.DecFallback(yyv23, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Assert = nil
	} else {
		yyv25 := &x.Assert
		yym26 := z.DecBinary()
		_ = yym26
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv25) {
		} else {
			z.DecFallback(yyv25, true)
		}
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveFieldStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveFieldStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveFieldStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveFieldStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineIndexStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			var yyn3 bool
			if x.Name == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `name`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cols == nil {
					r.EncodeNil()
				} else {
					x.Cols.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `cols`)
				r.WriteMapElemValue()
				if x.Cols == nil {
					r.EncodeNil()
				} else {
					x.Cols.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `uniq`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineIndexStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DefineIndexStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "cols":
			if r.TryDecodeAsNil() {
				x.Cols = nil
			} else {
				yyv5 := &x.Cols
				yyv5.CodecDecodeSelf(d)
			}
		case "uniq":
			if r.TryDecodeAsNil() {
				x.Uniq = false
			} else {
				yyv6 := &x.Uniq
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*bool)(yyv6)) = r.DecodeBool()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineIndexStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj8 int
	var yyb8 bool
	var yyhl8 bool = l >= 0
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cols = nil
	} else {
		yyv10 := &x.Cols
		yyv10.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Uniq = false
	} else {
		yyv11 := &x.Uniq
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			*((*bool)(yyv11)) = r.DecodeBool()
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveIndexStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RemoveIndexStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *RemoveIndexStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RemoveIndexStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x Exprs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encExprs((Exprs)(x), e)
		}
	}
}

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

func (x *All) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *All) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *All) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *All) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *Any) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Any) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Any) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Any) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *Void) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Void) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Void) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Void) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *Empty) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Empty) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Empty) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Empty) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj4-1, "")
	}
	r.ReadArrayEnd()
}

func (x *Field) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Field))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Field`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Field))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Alias))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Alias`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Alias))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Field) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Field) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv4 := &x.Expr
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		case "Field":
			if r.TryDecodeAsNil() {
				x.Field = ""
			} else {
				yyv6 := &x.Field
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*string)(yyv6)) = r.DecodeString()
				}
			}
		case "Alias":
			if r.TryDecodeAsNil() {
				x.Alias = ""
			} else {
				yyv8 := &x.Alias
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*string)(yyv8)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Field) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv11 := &x.Expr
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Field = ""
	} else {
		yyv13 := &x.Field
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*string)(yyv13)) = r.DecodeString()
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Alias = ""
	} else {
		yyv15 := &x.Alias
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*string)(yyv15)) = r.DecodeString()
		}
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	r.ReadArrayEnd()
}

func (x Fields) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encFields((Fields)(x), e)
		}
	}
}

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

func (x *Group) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Group) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Group) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv4 := &x.Expr
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Group) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv7 := &x.Expr
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Groups) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encGroups((Groups)(x), e)
		}
	}
}

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

func (x *Order) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeBool(bool(x.Dir))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Dir`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeBool(bool(x.Dir))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yy10 := &x.Tag
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.EncExt(yy10) {
				} else {
					z.EncFallback(yy10)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Tag`)
				r.WriteMapElemValue()
				yy12 := &x.Tag
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else if z.HasExtensions() && z.EncExt(yy12) {
				} else {
					z.EncFallback(yy12)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Order) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Order) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv4 := &x.Expr
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		case "Dir":
			if r.TryDecodeAsNil() {
				x.Dir = false
			} else {
				yyv6 := &x.Dir
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*bool)(yyv6)) = r.DecodeBool()
				}
			}
		case "Tag":
			if r.TryDecodeAsNil() {
				x.Tag = pkg1_language.Tag{}
			} else {
				yyv8 := &x.Tag
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					z.DecFallback(yyv8, false)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Order) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv11 := &x.Expr
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Dir = false
	} else {
		yyv13 := &x.Dir
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*bool)(yyv13)) = r.DecodeBool()
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Tag = pkg1_language.Tag{}
	} else {
		yyv15 := &x.Tag
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			z.DecFallback(yyv15, false)
		}
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	r.ReadArrayEnd()
}

func (x Orders) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encOrders((Orders)(x), e)
		}
	}
}

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

func (x *SubExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Expr) {
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *SubExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *SubExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv4 := &x.Expr
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *SubExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv7 := &x.Expr
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *IfelExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					x.Cond.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					x.Cond.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					x.Then.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Then`)
				r.WriteMapElemValue()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					x.Then.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Else) {
					} else {
						z.EncFallback(x.Else)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Else`)
				r.WriteMapElemValue()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Else) {
					} else {
						z.EncFallback(x.Else)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *IfelExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *IfelExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv4 := &x.Cond
				yyv4.CodecDecodeSelf(d)
			}
		case "Then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				yyv5 := &x.Then
				yyv5.CodecDecodeSelf(d)
			}
		case "Else":
			if r.TryDecodeAsNil() {
				x.Else = nil
			} else {
				yyv6 := &x.Else
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else {
					z.DecFallback(yyv6, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *IfelExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv9 := &x.Cond
		yyv9.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Then = nil
	} else {
		yyv10 := &x.Then
		yyv10.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Else = nil
	} else {
		yyv11 := &x.Else
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x *FuncExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Name))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Name`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Args == nil {
					r.EncodeNil()
				} else {
					x.Args.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Args`)
				r.WriteMapElemValue()
				if x.Args == nil {
					r.EncodeNil()
				} else {
					x.Args.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *FuncExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *FuncExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				yyv4 := &x.Name
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "Args":
			if r.TryDecodeAsNil() {
				x.Args = nil
			} else {
				yyv6 := &x.Args
				yyv6.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *FuncExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj7 int
	var yyb7 bool
	var yyhl7 bool = l >= 0
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		yyv8 := &x.Name
		yym9 := z.DecBinary()
		_ = yym9
		if false {
		} else {
			*((*string)(yyv8)) = r.DecodeString()
		}
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Args = nil
	} else {
		yyv10 := &x.Args
		yyv10.CodecDecodeSelf(d)
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x *ItemExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.LHS) {
					} else {
						z.EncFallback(x.LHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `LHS`)
				r.WriteMapElemValue()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.LHS) {
					} else {
						z.EncFallback(x.LHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Op) {
				} else if yym7 {
					z.EncBinaryMarshal(x.Op)
				} else if !yym7 {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Op`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Op) {
				} else if yym8 {
					z.EncBinaryMarshal(x.Op)
				} else if !yym8 {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.RHS) {
					} else {
						z.EncFallback(x.RHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `RHS`)
				r.WriteMapElemValue()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.RHS) {
					} else {
						z.EncFallback(x.RHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *ItemExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *ItemExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "LHS":
			if r.TryDecodeAsNil() {
				x.LHS = nil
			} else {
				yyv4 := &x.LHS
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		case "Op":
			if r.TryDecodeAsNil() {
				x.Op = 0
			} else {
				yyv6 := &x.Op
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else if yym7 {
					z.DecBinaryUnmarshal(yyv6)
				} else {
					*((*int16)(yyv6)) = int16(r.DecodeInt(16))
				}
			}
		case "RHS":
			if r.TryDecodeAsNil() {
				x.RHS = nil
			} else {
				yyv8 := &x.RHS
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					z.DecFallback(yyv8, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *ItemExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.LHS = nil
	} else {
		yyv11 := &x.LHS
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Op = 0
	} else {
		yyv13 := &x.Op
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv13) {
		} else if yym14 {
			z.DecBinaryUnmarshal(yyv13)
		} else {
			*((*int16)(yyv13)) = int16(r.DecodeInt(16))
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.RHS = nil
	} else {
		yyv15 := &x.RHS
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			z.DecFallback(yyv15, true)
		}
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	r.ReadArrayEnd()
}

func (x *BinaryExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.LHS) {
					} else {
						z.EncFallback(x.LHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `LHS`)
				r.WriteMapElemValue()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.LHS) {
					} else {
						z.EncFallback(x.LHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Op) {
				} else if yym7 {
					z.EncBinaryMarshal(x.Op)
				} else if !yym7 {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Op`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Op) {
				} else if yym8 {
					z.EncBinaryMarshal(x.Op)
				} else if !yym8 {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.RHS) {
					} else {
						z.EncFallback(x.RHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `RHS`)
				r.WriteMapElemValue()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.RHS) {
					} else {
						z.EncFallback(x.RHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *BinaryExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *BinaryExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "LHS":
			if r.TryDecodeAsNil() {
				x.LHS = nil
			} else {
				yyv4 := &x.LHS
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		case "Op":
			if r.TryDecodeAsNil() {
				x.Op = 0
			} else {
				yyv6 := &x.Op
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else if yym7 {
					z.DecBinaryUnmarshal(yyv6)
				} else {
					*((*int16)(yyv6)) = int16(r.DecodeInt(16))
				}
			}
		case "RHS":
			if r.TryDecodeAsNil() {
				x.RHS = nil
			} else {
				yyv8 := &x.RHS
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					z.DecFallback(yyv8, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *BinaryExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj10 int
	var yyb10 bool
	var yyhl10 bool = l >= 0
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.LHS = nil
	} else {
		yyv11 := &x.LHS
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Op = 0
	} else {
		yyv13 := &x.Op
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv13) {
		} else if yym14 {
			z.DecBinaryUnmarshal(yyv13)
		} else {
			*((*int16)(yyv13)) = int16(r.DecodeInt(16))
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.RHS = nil
	} else {
		yyv15 := &x.RHS
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			z.DecFallback(yyv15, true)
		}
	}
	for {
		yyj10++
		if yyhl10 {
			yyb10 = yyj10 > l
		} else {
			yyb10 = r.CheckBreak()
		}
		if yyb10 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj10-1, "")
	}
	r.ReadArrayEnd()
}

func (x *PathExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *PathExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *PathExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				yyv4 := &x.Expr
				yyv4.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *PathExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		yyv6 := &x.Expr
		yyv6.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x *PartExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Part == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Part) {
					} else {
						z.EncFallback(x.Part)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Part`)
				r.WriteMapElemValue()
				if x.Part == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Part) {
					} else {
						z.EncFallback(x.Part)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *PartExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *PartExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Part":
			if r.TryDecodeAsNil() {
				x.Part = nil
			} else {
				yyv4 := &x.Part
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *PartExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Part = nil
	} else {
		yyv7 := &x.Part
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *JoinExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Join) {
				} else if yym4 {
					z.EncBinaryMarshal(x.Join)
				} else if !yym4 {
					z.EncTextMarshal(x.Join)
				} else {
					r.EncodeInt(int64(x.Join))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Join`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.EncExt(x.Join) {
				} else if yym5 {
					z.EncBinaryMarshal(x.Join)
				} else if !yym5 {
					z.EncTextMarshal(x.Join)
				} else {
					r.EncodeInt(int64(x.Join))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *JoinExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *JoinExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Join":
			if r.TryDecodeAsNil() {
				x.Join = 0
			} else {
				yyv4 := &x.Join
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else if yym5 {
					z.DecBinaryUnmarshal(yyv4)
				} else {
					*((*int16)(yyv4)) = int16(r.DecodeInt(16))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *JoinExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Join = 0
	} else {
		yyv7 := &x.Join
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else if yym8 {
			z.DecBinaryUnmarshal(yyv7)
		} else {
			*((*int16)(yyv7)) = int16(r.DecodeInt(16))
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *SubpExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `What`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			var yyn6 bool
			if x.Name == nil {
				yyn6 = true
				goto LABEL6
			}
		LABEL6:
			if yyr2 || yy2arr2 {
				if yyn6 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Name`)
				r.WriteMapElemValue()
				if yyn6 {
					r.EncodeNil()
				} else {
					if x.Name == nil {
						r.EncodeNil()
					} else {
						x.Name.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Cond) {
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *SubpExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *SubpExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "What":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				yyv4 := &x.What
				yyv4.CodecDecodeSelf(d)
			}
		case "Name":
			if x.Name == nil {
				x.Name = new(Ident)
			}
			if r.TryDecodeAsNil() {
				if x.Name != nil {
					x.Name = nil
				}
			} else {
				if x.Name == nil {
					x.Name = new(Ident)
				}
				x.Name.CodecDecodeSelf(d)
			}
		case "Cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				yyv6 := &x.Cond
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else {
					z.DecFallback(yyv6, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *SubpExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		yyv9 := &x.What
		yyv9.CodecDecodeSelf(d)
	}
	if x.Name == nil {
		x.Name = new(Ident)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}
		x.Name.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		yyv11 := &x.Cond
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv11) {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x *PermExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Select == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Select) {
					} else {
						z.EncFallback(x.Select)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Select`)
				r.WriteMapElemValue()
				if x.Select == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Select) {
					} else {
						z.EncFallback(x.Select)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Create == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Create) {
					} else {
						z.EncFallback(x.Create)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Create`)
				r.WriteMapElemValue()
				if x.Create == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Create) {
					} else {
						z.EncFallback(x.Create)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Update == nil {
					r.EncodeNil()
				} else {
					yym10 := z.EncBinary()
					_ = yym10
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Update) {
					} else {
						z.EncFallback(x.Update)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Update`)
				r.WriteMapElemValue()
				if x.Update == nil {
					r.EncodeNil()
				} else {
					yym11 := z.EncBinary()
					_ = yym11
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Update) {
					} else {
						z.EncFallback(x.Update)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Delete == nil {
					r.EncodeNil()
				} else {
					yym13 := z.EncBinary()
					_ = yym13
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Delete) {
					} else {
						z.EncFallback(x.Delete)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Delete`)
				r.WriteMapElemValue()
				if x.Delete == nil {
					r.EncodeNil()
				} else {
					yym14 := z.EncBinary()
					_ = yym14
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Delete) {
					} else {
						z.EncFallback(x.Delete)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *PermExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *PermExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Select":
			if r.TryDecodeAsNil() {
				x.Select = nil
			} else {
				yyv4 := &x.Select
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		case "Create":
			if r.TryDecodeAsNil() {
				x.Create = nil
			} else {
				yyv6 := &x.Create
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv6) {
				} else {
					z.DecFallback(yyv6, true)
				}
			}
		case "Update":
			if r.TryDecodeAsNil() {
				x.Update = nil
			} else {
				yyv8 := &x.Update
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv8) {
				} else {
					z.DecFallback(yyv8, true)
				}
			}
		case "Delete":
			if r.TryDecodeAsNil() {
				x.Delete = nil
			} else {
				yyv10 := &x.Delete
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv10) {
				} else {
					z.DecFallback(yyv10, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *PermExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Select = nil
	} else {
		yyv13 := &x.Select
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv13) {
		} else {
			z.DecFallback(yyv13, true)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Create = nil
	} else {
		yyv15 := &x.Create
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv15) {
		} else {
			z.DecFallback(yyv15, true)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Update = nil
	} else {
		yyv17 := &x.Update
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv17) {
		} else {
			z.DecFallback(yyv17, true)
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Delete = nil
	} else {
		yyv19 := &x.Delete
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv19) {
		} else {
			z.DecFallback(yyv19, true)
		}
	}
	for {
		yyj12++
		if yyhl12 {
			yyb12 = yyj12 > l
		} else {
			yyb12 = r.CheckBreak()
		}
		if yyb12 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj12-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DataExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						h.encSlicePtrtoItemExpression(([]*ItemExpression)(x.Data), e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						h.encSlicePtrtoItemExpression(([]*ItemExpression)(x.Data), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DataExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DataExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv4 := &x.Data
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					h.decSlicePtrtoItemExpression((*[]*ItemExpression)(yyv4), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DataExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv7 := &x.Data
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else {
			h.decSlicePtrtoItemExpression((*[]*ItemExpression)(yyv7), d)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DiffExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DiffExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *DiffExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv4 := &x.Data
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DiffExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv7 := &x.Data
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *MergeExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *MergeExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *MergeExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv4 := &x.Data
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *MergeExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv7 := &x.Data
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *ContentExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else if z.HasExtensions() && z.EncExt(x.Data) {
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *ContentExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *ContentExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				yyv4 := &x.Data
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else if z.HasExtensions() && z.DecExt(yyv4) {
				} else {
					z.DecFallback(yyv4, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *ContentExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		yyv7 := &x.Data
		yym8 := z.DecBinary()
		_ = yym8
		if false {
		} else if z.HasExtensions() && z.DecExt(yyv7) {
		} else {
			z.DecFallback(yyv7, true)
		}
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x *Model) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `TB`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeFloat64(float64(x.MIN))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `MIN`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeFloat64(float64(x.MIN))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym10 := z.EncBinary()
				_ = yym10
				if false {
				} else {
					r.EncodeFloat64(float64(x.INC))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `INC`)
				r.WriteMapElemValue()
				yym11 := z.EncBinary()
				_ = yym11
				if false {
				} else {
					r.EncodeFloat64(float64(x.INC))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym13 := z.EncBinary()
				_ = yym13
				if false {
				} else {
					r.EncodeFloat64(float64(x.MAX))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `MAX`)
				r.WriteMapElemValue()
				yym14 := z.EncBinary()
				_ = yym14
				if false {
				} else {
					r.EncodeFloat64(float64(x.MAX))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Model) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Model) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				yyv4 := &x.TB
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "MIN":
			if r.TryDecodeAsNil() {
				x.MIN = 0
			} else {
				yyv6 := &x.MIN
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*float64)(yyv6)) = float64(r.DecodeFloat(false))
				}
			}
		case "INC":
			if r.TryDecodeAsNil() {
				x.INC = 0
			} else {
				yyv8 := &x.INC
				yym9 := z.DecBinary()
				_ = yym9
				if false {
				} else {
					*((*float64)(yyv8)) = float64(r.DecodeFloat(false))
				}
			}
		case "MAX":
			if r.TryDecodeAsNil() {
				x.MAX = 0
			} else {
				yyv10 := &x.MAX
				yym11 := z.DecBinary()
				_ = yym11
				if false {
				} else {
					*((*float64)(yyv10)) = float64(r.DecodeFloat(false))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Model) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.TB = ""
	} else {
		yyv13 := &x.TB
		yym14 := z.DecBinary()
		_ = yym14
		if false {
		} else {
			*((*string)(yyv13)) = r.DecodeString()
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.MIN = 0
	} else {
		yyv15 := &x.MIN
		yym16 := z.DecBinary()
		_ = yym16
		if false {
		} else {
			*((*float64)(yyv15)) = float64(r.DecodeFloat(false))
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.INC = 0
	} else {
		yyv17 := &x.INC
		yym18 := z.DecBinary()
		_ = yym18
		if false {
		} else {
			*((*float64)(yyv17)) = float64(r.DecodeFloat(false))
		}
	}
	yyj12++
	if yyhl12 {
		yyb12 = yyj12 > l
	} else {
		yyb12 = r.CheckBreak()
	}
	if yyb12 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.MAX = 0
	} else {
		yyv19 := &x.MAX
		yym20 := z.DecBinary()
		_ = yym20
		if false {
		} else {
			*((*float64)(yyv19)) = float64(r.DecodeFloat(false))
		}
	}
	for {
		yyj12++
		if yyhl12 {
			yyb12 = yyj12 > l
		} else {
			yyb12 = r.CheckBreak()
		}
		if yyb12 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj12-1, "")
	}
	r.ReadArrayEnd()
}

func (x Params) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encParams((Params)(x), e)
		}
	}
}

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

func (x *Param) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `ID`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Param) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Param) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Param) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv7 := &x.ID
		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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Values) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encValues((Values)(x), e)
		}
	}
}

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

func (x *Value) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `ID`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Value) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Value) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Value) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv7 := &x.ID
		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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Idents) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encIdents((Idents)(x), e)
		}
	}
}

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

func (x *Ident) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `ID`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Ident) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Ident) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				yyv4 := &x.ID
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Ident) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		yyv7 := &x.ID
		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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Tables) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encTables((Tables)(x), e)
		}
	}
}

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

func (x *Table) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `TB`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Table) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Table) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				yyv4 := &x.TB
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Table) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.TB = ""
	} else {
		yyv7 := &x.TB
		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
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Batchs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encBatchs((Batchs)(x), e)
		}
	}
}

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

func (x *Batch) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `TB`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.BA == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else {
						h.encSlicePtrtoThing(([]*Thing)(x.BA), e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `BA`)
				r.WriteMapElemValue()
				if x.BA == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else {
						h.encSlicePtrtoThing(([]*Thing)(x.BA), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Batch) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Batch) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				yyv4 := &x.TB
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "BA":
			if r.TryDecodeAsNil() {
				x.BA = nil
			} else {
				yyv6 := &x.BA
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					h.decSlicePtrtoThing((*[]*Thing)(yyv6), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Batch) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.TB = ""
	} else {
		yyv9 := &x.TB
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			*((*string)(yyv9)) = r.DecodeString()
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.BA = nil
	} else {
		yyv11 := &x.BA
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			h.decSlicePtrtoThing((*[]*Thing)(yyv11), d)
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x Things) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encThings((Things)(x), e)
		}
	}
}

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

func (x *Thing) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `TB`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF84085, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.ID == nil {
					r.EncodeNil()
				} else {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else {
						z.EncFallback(x.ID)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `ID`)
				r.WriteMapElemValue()
				if x.ID == nil {
					r.EncodeNil()
				} else {
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else {
						z.EncFallback(x.ID)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Thing) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Thing) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				yyv4 := &x.TB
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*string)(yyv4)) = r.DecodeString()
				}
			}
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = nil
			} else {
				yyv6 := &x.ID
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					z.DecFallback(yyv6, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Thing) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.TB = ""
	} else {
		yyv9 := &x.TB
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			*((*string)(yyv9)) = r.DecodeString()
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = nil
	} else {
		yyv11 := &x.ID
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			z.DecFallback(yyv11, true)
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x Points) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encPoints((Points)(x), e)
		}
	}
}

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

func (x *Point) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym4 := z.EncBinary()
				_ = yym4
				if false {
				} else {
					r.EncodeFloat64(float64(x.LA))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `LA`)
				r.WriteMapElemValue()
				yym5 := z.EncBinary()
				_ = yym5
				if false {
				} else {
					r.EncodeFloat64(float64(x.LA))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeFloat64(float64(x.LO))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `LO`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeFloat64(float64(x.LO))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Point) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Point) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "LA":
			if r.TryDecodeAsNil() {
				x.LA = 0
			} else {
				yyv4 := &x.LA
				yym5 := z.DecBinary()
				_ = yym5
				if false {
				} else {
					*((*float64)(yyv4)) = float64(r.DecodeFloat(false))
				}
			}
		case "LO":
			if r.TryDecodeAsNil() {
				x.LO = 0
			} else {
				yyv6 := &x.LO
				yym7 := z.DecBinary()
				_ = yym7
				if false {
				} else {
					*((*float64)(yyv6)) = float64(r.DecodeFloat(false))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Point) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.LA = 0
	} else {
		yyv9 := &x.LA
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			*((*float64)(yyv9)) = float64(r.DecodeFloat(false))
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.LO = 0
	} else {
		yyv11 := &x.LO
		yym12 := z.DecBinary()
		_ = yym12
		if false {
		} else {
			*((*float64)(yyv11)) = float64(r.DecodeFloat(false))
		}
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x Circles) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encCircles((Circles)(x), e)
		}
	}
}

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

func (x *Circle) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			var yyn3 bool
			if x.CE == nil {
				yyn3 = true
				goto LABEL3
			}
		LABEL3:
			if yyr2 || yy2arr2 {
				if yyn3 {
					r.WriteArrayElem()
					r.EncodeNil()
				} else {
					r.WriteArrayElem()
					if x.CE == nil {
						r.EncodeNil()
					} else {
						x.CE.CodecEncodeSelf(e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `CE`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.CE == nil {
						r.EncodeNil()
					} else {
						x.CE.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yym7 := z.EncBinary()
				_ = yym7
				if false {
				} else {
					r.EncodeFloat64(float64(x.RA))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `RA`)
				r.WriteMapElemValue()
				yym8 := z.EncBinary()
				_ = yym8
				if false {
				} else {
					r.EncodeFloat64(float64(x.RA))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Circle) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Circle) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "CE":
			if x.CE == nil {
				x.CE = new(Point)
			}
			if r.TryDecodeAsNil() {
				if x.CE != nil {
					x.CE = nil
				}
			} else {
				if x.CE == nil {
					x.CE = new(Point)
				}
				x.CE.CodecDecodeSelf(d)
			}
		case "RA":
			if r.TryDecodeAsNil() {
				x.RA = 0
			} else {
				yyv5 := &x.RA
				yym6 := z.DecBinary()
				_ = yym6
				if false {
				} else {
					*((*float64)(yyv5)) = float64(r.DecodeFloat(false))
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Circle) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj7 int
	var yyb7 bool
	var yyhl7 bool = l >= 0
	if x.CE == nil {
		x.CE = new(Point)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if x.CE != nil {
			x.CE = nil
		}
	} else {
		if x.CE == nil {
			x.CE = new(Point)
		}
		x.CE.CodecDecodeSelf(d)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.RA = 0
	} else {
		yyv9 := &x.RA
		yym10 := z.DecBinary()
		_ = yym10
		if false {
		} else {
			*((*float64)(yyv9)) = float64(r.DecodeFloat(false))
		}
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x Polygons) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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.encPolygons((Polygons)(x), e)
		}
	}
}

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

func (x *Polygon) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer4085
	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 if !yym1 && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.PS == nil {
					r.EncodeNil()
				} else {
					x.PS.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF84085, `PS`)
				r.WriteMapElemValue()
				if x.PS == nil {
					r.EncodeNil()
				} else {
					x.PS.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Polygon) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer4085
	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 == codecSelferValueTypeMap4085 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray4085 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct4085)
		}
	}
}

func (x *Polygon) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	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
			}
		}
		r.ReadMapElemKey()
		yys3Slc = r.DecodeStringAsBytes()
		yys3 := string(yys3Slc)
		r.ReadMapElemValue()
		switch yys3 {
		case "PS":
			if r.TryDecodeAsNil() {
				x.PS = nil
			} else {
				yyv4 := &x.PS
				yyv4.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Polygon) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj5 int
	var yyb5 bool
	var yyhl5 bool = l >= 0
	yyj5++
	if yyhl5 {
		yyb5 = yyj5 > l
	} else {
		yyb5 = r.CheckBreak()
	}
	if yyb5 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.PS = nil
	} else {
		yyv6 := &x.PS
		yyv6.CodecDecodeSelf(d)
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x codecSelfer4085) encStatements(v Statements, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yym2 := z.EncBinary()
			_ = yym2
			if false {
			} else if z.HasExtensions() && z.EncExt(yyv1) {
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decStatements(v *Statements, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []Statement{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]Statement, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]Statement, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					yyv1[yyj1] = nil
				} else {
					yyv2 := &yyv1[yyj1]
					yym3 := z.DecBinary()
					_ = yym3
					if false {
					} else if z.HasExtensions() && z.DecExt(yyv2) {
					} else {
						z.DecFallback(yyv2, true)
					}
				}

			}

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

}

func (x codecSelfer4085) encExprs(v Exprs, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yym2 := z.EncBinary()
			_ = yym2
			if false {
			} else if z.HasExtensions() && z.EncExt(yyv1) {
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decExprs(v *Exprs, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []Expr{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]Expr, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]Expr, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					yyv1[yyj1] = nil
				} else {
					yyv2 := &yyv1[yyj1]
					yym3 := z.DecBinary()
					_ = yym3
					if false {
					} else if z.HasExtensions() && z.DecExt(yyv2) {
					} else {
						z.DecFallback(yyv2, true)
					}
				}

			}

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

}

func (x codecSelfer4085) encFields(v Fields, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decFields(v *Fields, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Field{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Field, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Field, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Field{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Field)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encGroups(v Groups, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decGroups(v *Groups, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Group{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Group, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Group, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Group{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Group)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encOrders(v Orders, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decOrders(v *Orders, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Order{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Order, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Order, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Order{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Order)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encSlicePtrtoItemExpression(v []*ItemExpression, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decSlicePtrtoItemExpression(v *[]*ItemExpression, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*ItemExpression{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*ItemExpression, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*ItemExpression, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = ItemExpression{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ItemExpression)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encParams(v Params, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decParams(v *Params, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Param{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Param, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Param, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Param{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Param)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encValues(v Values, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decValues(v *Values, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Value{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Value, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Value, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Value{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Value)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encIdents(v Idents, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decIdents(v *Idents, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Ident{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Ident, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Ident, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Ident{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Ident)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encTables(v Tables, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decTables(v *Tables, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Table{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Table, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Table, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Table{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Table)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encBatchs(v Batchs, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decBatchs(v *Batchs, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Batch{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Batch, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Batch, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Batch{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Batch)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encSlicePtrtoThing(v []*Thing, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decSlicePtrtoThing(v *[]*Thing, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Thing{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Thing, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Thing, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Thing{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Thing)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encThings(v Things, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decThings(v *Things, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Thing{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Thing, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Thing, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Thing{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Thing)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encPoints(v Points, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decPoints(v *Points, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Point{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Point, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Point, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Point{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Point)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encCircles(v Circles, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decCircles(v *Circles, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Circle{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Circle, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Circle, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Circle{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Circle)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}

func (x codecSelfer4085) encPolygons(v Polygons, e *codec1978.Encoder) {
	var h codecSelfer4085
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			yyv1.CodecEncodeSelf(e)
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer4085) decPolygons(v *Polygons, d *codec1978.Decoder) {
	var h codecSelfer4085
	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 = []*Polygon{}
			yyc1 = true
		} else if len(yyv1) != 0 {
			yyv1 = yyv1[:0]
			yyc1 = true
		}
	} else {
		yyhl1 := yyl1 > 0
		var yyrl1 int
		_ = yyrl1
		if yyhl1 {
			if yyl1 > cap(yyv1) {
				yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				if yyrl1 <= cap(yyv1) {
					yyv1 = yyv1[:yyrl1]
				} else {
					yyv1 = make([]*Polygon, yyrl1)
				}
				yyc1 = true
			} else if yyl1 != len(yyv1) {
				yyv1 = yyv1[:yyl1]
				yyc1 = true
			}
		}
		var yyj1 int
		// var yydn1 bool
		for ; (yyhl1 && yyj1 < yyl1) || !(yyhl1 || r.CheckBreak()); yyj1++ {
			if yyj1 == 0 && len(yyv1) == 0 {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Polygon, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)
			// yydn1 = r.TryDecodeAsNil()

			// if indefinite, etc, then expand the slice if necessary
			var yydb1 bool
			if yyj1 >= len(yyv1) {
				yyv1 = append(yyv1, nil)
				yyc1 = true

			}
			if yydb1 {
				z.DecSwallow()
			} else {
				if r.TryDecodeAsNil() {
					if yyv1[yyj1] != nil {
						*yyv1[yyj1] = Polygon{}
					}
				} else {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Polygon)
					}
					yyw2 := yyv1[yyj1]
					yyw2.CodecDecodeSelf(d)
				}

			}

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

}