surrealpatch/sql/ast.gen.go

// Code generated by codecgen - DO NOT EDIT.

package sql

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

const (
	// ----- content types ----
	codecSelferCcUTF89697 = 1
	codecSelferCcRAW9697  = 0
	// ----- value types used ----
	codecSelferValueTypeArray9697  = 10
	codecSelferValueTypeMap9697    = 9
	codecSelferValueTypeString9697 = 6
	codecSelferValueTypeInt9697    = 2
	codecSelferValueTypeUint9697   = 3
	codecSelferValueTypeFloat9697  = 4
	codecSelferBitsize9697         = uint8(32 << (^uint(0) >> 63))
)

var (
	errCodecSelferOnlyMapOrArrayEncodeToStruct9697 = errors.New(`only encoded map or array can be decoded into a struct`)
)

type codecSelfer9697 struct{}

func init() {
	if codec1978.GenVersion != 8 {
		_, file, _, _ := runtime.Caller(0)
		panic("codecgen version mismatch: current: 8, need " + strconv.FormatInt(int64(codec1978.GenVersion), 10) + ". Re-generate file: " + file)
	}
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Query) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Statements":
			if r.TryDecodeAsNil() {
				x.Statements = nil
			} else {
				x.Statements.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 codecSelfer9697
	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 {
		x.Statements.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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encStatements((Statements)(x), e)
		}
	}
}

func (x *Statements) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decStatements((*Statements)(x), d)
	}
}

func (x *BeginStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *BeginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *CancelStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *CommitStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *UseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *InfoStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.Else)); yyxt10 != nil {
						z.EncExtension(x.Else, yyxt10)
					} else {
						z.EncFallback(x.Else)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `else`)
				r.WriteMapElemValue()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.Else)); yyxt11 != nil {
						z.EncExtension(x.Else, yyxt11)
					} else {
						z.EncFallback(x.Else)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *IfStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *IfStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				x.Cond.CodecDecodeSelf(d)
			}
		case "then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				x.Then.CodecDecodeSelf(d)
			}
		case "else":
			if r.TryDecodeAsNil() {
				x.Else = nil
			} else {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Else)); yyxt7 != nil {
					z.DecExtension(x.Else, yyxt7)
				} else {
					z.DecFallback(&x.Else, 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 codecSelfer9697
	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 {
		x.Cond.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 {
		x.Then.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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.Else)); yyxt12 != nil {
			z.DecExtension(x.Else, yyxt12)
		} else {
			z.DecFallback(&x.Else, 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 *RunStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Expr)); yyxt4 != nil {
						z.EncExtension(x.Expr, yyxt4)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
						z.EncExtension(x.Expr, yyxt5)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *RunStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RunStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
					z.DecExtension(x.Expr, yyxt5)
				} else {
					z.DecFallback(&x.Expr, true)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RunStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Expr)); yyxt8 != nil {
			z.DecExtension(x.Expr, yyxt8)
		} else {
			z.DecFallback(&x.Expr, 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 *LetStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *LetStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *ReturnStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `ID`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.FB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `FB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.FB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Diff))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `diff`)
				r.WriteMapElemValue()
				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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt28 := z.Extension(z.I2Rtid(x.Cond)); yyxt28 != nil {
						z.EncExtension(x.Cond, yyxt28)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt29 := z.Extension(z.I2Rtid(x.Cond)); yyxt29 != nil {
						z.EncExtension(x.Cond, yyxt29)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *LiveStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *LiveStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				x.ID = (string)(r.DecodeString())
			}
		case "FB":
			if r.TryDecodeAsNil() {
				x.FB = ""
			} else {
				x.FB = (string)(r.DecodeString())
			}
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "diff":
			if r.TryDecodeAsNil() {
				x.Diff = false
			} else {
				x.Diff = (bool)(r.DecodeBool())
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				x.Expr.CodecDecodeSelf(d)
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(x.Cond)); yyxt13 != nil {
					z.DecExtension(x.Cond, yyxt13)
				} else {
					z.DecFallback(&x.Cond, 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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj14 int
	var yyb14 bool
	var yyhl14 bool = l >= 0
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = ""
	} else {
		x.ID = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.FB = ""
	} else {
		x.FB = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Diff = false
	} else {
		x.Diff = (bool)(r.DecodeBool())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		x.Expr.CodecDecodeSelf(d)
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		if false {
		} else if yyxt24 := z.Extension(z.I2Rtid(x.Cond)); yyxt24 != nil {
			z.DecExtension(x.Cond, yyxt24)
		} else {
			z.DecFallback(&x.Cond, true)
		}
	}
	for {
		yyj14++
		if yyhl14 {
			yyb14 = yyj14 > l
		} else {
			yyb14 = r.CheckBreak()
		}
		if yyb14 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj14-1, "")
	}
	r.ReadArrayEnd()
}

func (x *KillStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(5)
			} else {
				r.WriteMapStart(5)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.FB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `FB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.FB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `what`)
				r.WriteMapElemValue()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *KillStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *KillStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "FB":
			if r.TryDecodeAsNil() {
				x.FB = ""
			} else {
				x.FB = (string)(r.DecodeString())
			}
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj9 int
	var yyb9 bool
	var yyhl9 bool = l >= 0
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.FB = ""
	} else {
		x.FB = (string)(r.DecodeString())
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	for {
		yyj9++
		if yyhl9 {
			yyb9 = yyj9 > l
		} else {
			yyb9 = r.CheckBreak()
		}
		if yyb9 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj9-1, "")
	}
	r.ReadArrayEnd()
}

func (x *SelectStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(13)
			} else {
				r.WriteMapStart(13)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					x.Expr.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt19 := z.Extension(z.I2Rtid(x.Cond)); yyxt19 != nil {
						z.EncExtension(x.Cond, yyxt19)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt20 := z.Extension(z.I2Rtid(x.Cond)); yyxt20 != nil {
						z.EncExtension(x.Cond, yyxt20)
					} 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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt28 := z.Extension(z.I2Rtid(x.Limit)); yyxt28 != nil {
						z.EncExtension(x.Limit, yyxt28)
					} else {
						z.EncFallback(x.Limit)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `limit`)
				r.WriteMapElemValue()
				if x.Limit == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt29 := z.Extension(z.I2Rtid(x.Limit)); yyxt29 != nil {
						z.EncExtension(x.Limit, yyxt29)
					} else {
						z.EncFallback(x.Limit)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Start == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt31 := z.Extension(z.I2Rtid(x.Start)); yyxt31 != nil {
						z.EncExtension(x.Start, yyxt31)
					} else {
						z.EncFallback(x.Start)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `start`)
				r.WriteMapElemValue()
				if x.Start == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt32 := z.Extension(z.I2Rtid(x.Start)); yyxt32 != nil {
						z.EncExtension(x.Start, yyxt32)
					} else {
						z.EncFallback(x.Start)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Version == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt34 := z.Extension(z.I2Rtid(x.Version)); yyxt34 != nil {
						z.EncExtension(x.Version, yyxt34)
					} else {
						z.EncFallback(x.Version)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `version`)
				r.WriteMapElemValue()
				if x.Version == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt35 := z.Extension(z.I2Rtid(x.Version)); yyxt35 != nil {
						z.EncExtension(x.Version, yyxt35)
					} else {
						z.EncFallback(x.Version)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt37 := z.Extension(z.I2Rtid(x.Timeout)); yyxt37 != nil {
					z.EncExtension(x.Timeout, yyxt37)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt38 := z.Extension(z.I2Rtid(x.Timeout)); yyxt38 != nil {
					z.EncExtension(x.Timeout, yyxt38)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *SelectStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				x.Expr.CodecDecodeSelf(d)
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				if false {
				} else if yyxt10 := z.Extension(z.I2Rtid(x.Cond)); yyxt10 != nil {
					z.DecExtension(x.Cond, yyxt10)
				} else {
					z.DecFallback(&x.Cond, true)
				}
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Group = nil
			} else {
				x.Group.CodecDecodeSelf(d)
			}
		case "order":
			if r.TryDecodeAsNil() {
				x.Order = nil
			} else {
				x.Order.CodecDecodeSelf(d)
			}
		case "limit":
			if r.TryDecodeAsNil() {
				x.Limit = nil
			} else {
				if false {
				} else if yyxt14 := z.Extension(z.I2Rtid(x.Limit)); yyxt14 != nil {
					z.DecExtension(x.Limit, yyxt14)
				} else {
					z.DecFallback(&x.Limit, true)
				}
			}
		case "start":
			if r.TryDecodeAsNil() {
				x.Start = nil
			} else {
				if false {
				} else if yyxt16 := z.Extension(z.I2Rtid(x.Start)); yyxt16 != nil {
					z.DecExtension(x.Start, yyxt16)
				} else {
					z.DecFallback(&x.Start, true)
				}
			}
		case "version":
			if r.TryDecodeAsNil() {
				x.Version = nil
			} else {
				if false {
				} else if yyxt18 := z.Extension(z.I2Rtid(x.Version)); yyxt18 != nil {
					z.DecExtension(x.Version, yyxt18)
				} else {
					z.DecFallback(&x.Version, true)
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt20 := z.Extension(z.I2Rtid(x.Timeout)); yyxt20 != nil {
					z.DecExtension(x.Timeout, yyxt20)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *SelectStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj22 int
	var yyb22 bool
	var yyhl22 bool = l >= 0
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		x.Expr.CodecDecodeSelf(d)
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		if false {
		} else if yyxt29 := z.Extension(z.I2Rtid(x.Cond)); yyxt29 != nil {
			z.DecExtension(x.Cond, yyxt29)
		} else {
			z.DecFallback(&x.Cond, true)
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Group = nil
	} else {
		x.Group.CodecDecodeSelf(d)
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Order = nil
	} else {
		x.Order.CodecDecodeSelf(d)
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Limit = nil
	} else {
		if false {
		} else if yyxt33 := z.Extension(z.I2Rtid(x.Limit)); yyxt33 != nil {
			z.DecExtension(x.Limit, yyxt33)
		} else {
			z.DecFallback(&x.Limit, true)
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Start = nil
	} else {
		if false {
		} else if yyxt35 := z.Extension(z.I2Rtid(x.Start)); yyxt35 != nil {
			z.DecExtension(x.Start, yyxt35)
		} else {
			z.DecFallback(&x.Start, true)
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Version = nil
	} else {
		if false {
		} else if yyxt37 := z.Extension(z.I2Rtid(x.Version)); yyxt37 != nil {
			z.DecExtension(x.Version, yyxt37)
		} else {
			z.DecFallback(&x.Version, true)
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt39 := z.Extension(z.I2Rtid(x.Timeout)); yyxt39 != nil {
			z.DecExtension(x.Timeout, yyxt39)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj22++
		if yyhl22 {
			yyb22 = yyj22 > l
		} else {
			yyb22 = r.CheckBreak()
		}
		if yyb22 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj22-1, "")
	}
	r.ReadArrayEnd()
}

func (x *CreateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt16 := z.Extension(z.I2Rtid(x.Data)); yyxt16 != nil {
						z.EncExtension(x.Data, yyxt16)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt17 := z.Extension(z.I2Rtid(x.Data)); yyxt17 != nil {
						z.EncExtension(x.Data, yyxt17)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt19 := z.Extension(z.I2Rtid(x.Echo)); yyxt19 != nil {
					z.EncExtension(x.Echo, yyxt19)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt20 := z.Extension(z.I2Rtid(x.Echo)); yyxt20 != nil {
					z.EncExtension(x.Echo, yyxt20)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt22 := z.Extension(z.I2Rtid(x.Timeout)); yyxt22 != nil {
					z.EncExtension(x.Timeout, yyxt22)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt23 := z.Extension(z.I2Rtid(x.Timeout)); yyxt23 != nil {
					z.EncExtension(x.Timeout, yyxt23)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *CreateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt9 := z.Extension(z.I2Rtid(x.Data)); yyxt9 != nil {
					z.DecExtension(x.Data, yyxt9)
				} else {
					z.DecFallback(&x.Data, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Echo)); yyxt11 != nil {
					z.DecExtension(x.Echo, yyxt11)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(x.Timeout)); yyxt13 != nil {
					z.DecExtension(x.Timeout, yyxt13)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *CreateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		if false {
		} else if yyxt21 := z.Extension(z.I2Rtid(x.Data)); yyxt21 != nil {
			z.DecExtension(x.Data, yyxt21)
		} else {
			z.DecFallback(&x.Data, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Echo)); yyxt23 != nil {
			z.DecExtension(x.Echo, yyxt23)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt25 := z.Extension(z.I2Rtid(x.Timeout)); yyxt25 != nil {
			z.DecExtension(x.Timeout, yyxt25)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	r.ReadArrayEnd()
}

func (x *UpdateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.What == nil {
					r.EncodeNil()
				} else {
					x.What.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt16 := z.Extension(z.I2Rtid(x.Data)); yyxt16 != nil {
						z.EncExtension(x.Data, yyxt16)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt17 := z.Extension(z.I2Rtid(x.Data)); yyxt17 != nil {
						z.EncExtension(x.Data, yyxt17)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt19 := z.Extension(z.I2Rtid(x.Cond)); yyxt19 != nil {
						z.EncExtension(x.Cond, yyxt19)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt20 := z.Extension(z.I2Rtid(x.Cond)); yyxt20 != nil {
						z.EncExtension(x.Cond, yyxt20)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt22 := z.Extension(z.I2Rtid(x.Echo)); yyxt22 != nil {
					z.EncExtension(x.Echo, yyxt22)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt23 := z.Extension(z.I2Rtid(x.Echo)); yyxt23 != nil {
					z.EncExtension(x.Echo, yyxt23)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt25 := z.Extension(z.I2Rtid(x.Timeout)); yyxt25 != nil {
					z.EncExtension(x.Timeout, yyxt25)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt26 := z.Extension(z.I2Rtid(x.Timeout)); yyxt26 != nil {
					z.EncExtension(x.Timeout, yyxt26)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *UpdateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt9 := z.Extension(z.I2Rtid(x.Data)); yyxt9 != nil {
					z.DecExtension(x.Data, yyxt9)
				} else {
					z.DecFallback(&x.Data, true)
				}
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Cond)); yyxt11 != nil {
					z.DecExtension(x.Cond, yyxt11)
				} else {
					z.DecFallback(&x.Cond, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(x.Echo)); yyxt13 != nil {
					z.DecExtension(x.Echo, yyxt13)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt15 := z.Extension(z.I2Rtid(x.Timeout)); yyxt15 != nil {
					z.DecExtension(x.Timeout, yyxt15)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *UpdateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj17 int
	var yyb17 bool
	var yyhl17 bool = l >= 0
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Data)); yyxt23 != nil {
			z.DecExtension(x.Data, yyxt23)
		} else {
			z.DecFallback(&x.Data, true)
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		if false {
		} else if yyxt25 := z.Extension(z.I2Rtid(x.Cond)); yyxt25 != nil {
			z.DecExtension(x.Cond, yyxt25)
		} else {
			z.DecFallback(&x.Cond, true)
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt27 := z.Extension(z.I2Rtid(x.Echo)); yyxt27 != nil {
			z.DecExtension(x.Echo, yyxt27)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt29 := z.Extension(z.I2Rtid(x.Timeout)); yyxt29 != nil {
			z.DecExtension(x.Timeout, yyxt29)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj17++
	if yyhl17 {
		yyb17 = yyj17 > l
	} else {
		yyb17 = r.CheckBreak()
	}
	if yyb17 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj17++
		if yyhl17 {
			yyb17 = yyj17 > l
		} else {
			yyb17 = r.CheckBreak()
		}
		if yyb17 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj17-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DeleteStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(9)
			} else {
				r.WriteMapStart(9)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Hard))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `hard`)
				r.WriteMapElemValue()
				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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt19 := z.Extension(z.I2Rtid(x.Cond)); yyxt19 != nil {
						z.EncExtension(x.Cond, yyxt19)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt20 := z.Extension(z.I2Rtid(x.Cond)); yyxt20 != nil {
						z.EncExtension(x.Cond, yyxt20)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt22 := z.Extension(z.I2Rtid(x.Echo)); yyxt22 != nil {
					z.EncExtension(x.Echo, yyxt22)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt23 := z.Extension(z.I2Rtid(x.Echo)); yyxt23 != nil {
					z.EncExtension(x.Echo, yyxt23)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt25 := z.Extension(z.I2Rtid(x.Timeout)); yyxt25 != nil {
					z.EncExtension(x.Timeout, yyxt25)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt26 := z.Extension(z.I2Rtid(x.Timeout)); yyxt26 != nil {
					z.EncExtension(x.Timeout, yyxt26)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DeleteStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "hard":
			if r.TryDecodeAsNil() {
				x.Hard = false
			} else {
				x.Hard = (bool)(r.DecodeBool())
			}
		case "what":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				if false {
				} else if yyxt10 := z.Extension(z.I2Rtid(x.Cond)); yyxt10 != nil {
					z.DecExtension(x.Cond, yyxt10)
				} else {
					z.DecFallback(&x.Cond, true)
				}
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				if false {
				} else if yyxt12 := z.Extension(z.I2Rtid(x.Echo)); yyxt12 != nil {
					z.DecExtension(x.Echo, yyxt12)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt14 := z.Extension(z.I2Rtid(x.Timeout)); yyxt14 != nil {
					z.DecExtension(x.Timeout, yyxt14)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DeleteStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj16 int
	var yyb16 bool
	var yyhl16 bool = l >= 0
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Hard = false
	} else {
		x.Hard = (bool)(r.DecodeBool())
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.What = nil
	} else {
		x.What.CodecDecodeSelf(d)
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Cond)); yyxt23 != nil {
			z.DecExtension(x.Cond, yyxt23)
		} else {
			z.DecFallback(&x.Cond, true)
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt25 := z.Extension(z.I2Rtid(x.Echo)); yyxt25 != nil {
			z.DecExtension(x.Echo, yyxt25)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt27 := z.Extension(z.I2Rtid(x.Timeout)); yyxt27 != nil {
			z.DecExtension(x.Timeout, yyxt27)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj16++
	if yyhl16 {
		yyb16 = yyj16 > l
	} else {
		yyb16 = r.CheckBreak()
	}
	if yyb16 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj16++
		if yyhl16 {
			yyb16 = yyj16 > l
		} else {
			yyb16 = r.CheckBreak()
		}
		if yyb16 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj16-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RelateStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(11)
			} else {
				r.WriteMapStart(11)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Type == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt13 := z.Extension(z.I2Rtid(x.Type)); yyxt13 != nil {
						z.EncExtension(x.Type, yyxt13)
					} else {
						z.EncFallback(x.Type)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `type`)
				r.WriteMapElemValue()
				if x.Type == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt14 := z.Extension(z.I2Rtid(x.Type)); yyxt14 != nil {
						z.EncExtension(x.Type, yyxt14)
					} 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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt22 := z.Extension(z.I2Rtid(x.Data)); yyxt22 != nil {
						z.EncExtension(x.Data, yyxt22)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt23 := z.Extension(z.I2Rtid(x.Data)); yyxt23 != nil {
						z.EncExtension(x.Data, yyxt23)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `uniq`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt28 := z.Extension(z.I2Rtid(x.Echo)); yyxt28 != nil {
					z.EncExtension(x.Echo, yyxt28)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt29 := z.Extension(z.I2Rtid(x.Echo)); yyxt29 != nil {
					z.EncExtension(x.Echo, yyxt29)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt31 := z.Extension(z.I2Rtid(x.Timeout)); yyxt31 != nil {
					z.EncExtension(x.Timeout, yyxt31)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt32 := z.Extension(z.I2Rtid(x.Timeout)); yyxt32 != nil {
					z.EncExtension(x.Timeout, yyxt32)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RelateStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = nil
			} else {
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Type)); yyxt8 != nil {
					z.DecExtension(x.Type, yyxt8)
				} else {
					z.DecFallback(&x.Type, true)
				}
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				x.From.CodecDecodeSelf(d)
			}
		case "with":
			if r.TryDecodeAsNil() {
				x.With = nil
			} else {
				x.With.CodecDecodeSelf(d)
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt12 := z.Extension(z.I2Rtid(x.Data)); yyxt12 != nil {
					z.DecExtension(x.Data, yyxt12)
				} else {
					z.DecFallback(&x.Data, true)
				}
			}
		case "uniq":
			if r.TryDecodeAsNil() {
				x.Uniq = false
			} else {
				x.Uniq = (bool)(r.DecodeBool())
			}
		case "echo":
			if r.TryDecodeAsNil() {
				x.Echo = 0
			} else {
				if false {
				} else if yyxt15 := z.Extension(z.I2Rtid(x.Echo)); yyxt15 != nil {
					z.DecExtension(x.Echo, yyxt15)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt17 := z.Extension(z.I2Rtid(x.Timeout)); yyxt17 != nil {
					z.DecExtension(x.Timeout, yyxt17)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *RelateStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 {
		x.KV = (string)(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 {
		x.NS = (string)(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 {
		x.DB = (string)(r.DecodeString())
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = nil
	} else {
		if false {
		} else if yyxt24 := z.Extension(z.I2Rtid(x.Type)); yyxt24 != nil {
			z.DecExtension(x.Type, yyxt24)
		} else {
			z.DecFallback(&x.Type, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		x.From.CodecDecodeSelf(d)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.With = nil
	} else {
		x.With.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 {
		if false {
		} else if yyxt28 := z.Extension(z.I2Rtid(x.Data)); yyxt28 != nil {
			z.DecExtension(x.Data, yyxt28)
		} else {
			z.DecFallback(&x.Data, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Uniq = false
	} else {
		x.Uniq = (bool)(r.DecodeBool())
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt31 := z.Extension(z.I2Rtid(x.Echo)); yyxt31 != nil {
			z.DecExtension(x.Echo, yyxt31)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 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 {
		if false {
		} else if yyxt33 := z.Extension(z.I2Rtid(x.Timeout)); yyxt33 != nil {
			z.DecExtension(x.Timeout, yyxt33)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj19++
		if yyhl19 {
			yyb19 = yyj19 > l
		} else {
			yyb19 = r.CheckBreak()
		}
		if yyb19 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj19-1, "")
	}
	r.ReadArrayEnd()
}

func (x *InsertStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt13 := z.Extension(z.I2Rtid(x.Data)); yyxt13 != nil {
						z.EncExtension(x.Data, yyxt13)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt14 := z.Extension(z.I2Rtid(x.Data)); yyxt14 != nil {
						z.EncExtension(x.Data, yyxt14)
					} 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(codecSelferCcUTF89697, `into`)
				r.WriteMapElemValue()
				if yyn15 {
					r.EncodeNil()
				} else {
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt19 := z.Extension(z.I2Rtid(x.Echo)); yyxt19 != nil {
					z.EncExtension(x.Echo, yyxt19)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt20 := z.Extension(z.I2Rtid(x.Echo)); yyxt20 != nil {
					z.EncExtension(x.Echo, yyxt20)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt22 := z.Extension(z.I2Rtid(x.Timeout)); yyxt22 != nil {
					z.EncExtension(x.Timeout, yyxt22)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt23 := z.Extension(z.I2Rtid(x.Timeout)); yyxt23 != nil {
					z.EncExtension(x.Timeout, yyxt23)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *InsertStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Data)); yyxt8 != nil {
					z.DecExtension(x.Data, yyxt8)
				} else {
					z.DecFallback(&x.Data, true)
				}
			}
		case "into":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Echo)); yyxt11 != nil {
					z.DecExtension(x.Echo, yyxt11)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(x.Timeout)); yyxt13 != nil {
					z.DecExtension(x.Timeout, yyxt13)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *InsertStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		if false {
		} else if yyxt20 := z.Extension(z.I2Rtid(x.Data)); yyxt20 != nil {
			z.DecExtension(x.Data, yyxt20)
		} else {
			z.DecFallback(&x.Data, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && x.Into != nil {
			x.Into = nil
		}
	} else {
		if x.Into == nil {
			x.Into = new(Table)
		}

		x.Into.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Echo)); yyxt23 != nil {
			z.DecExtension(x.Echo, yyxt23)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt25 := z.Extension(z.I2Rtid(x.Timeout)); yyxt25 != nil {
			z.DecExtension(x.Timeout, yyxt25)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	r.ReadArrayEnd()
}

func (x *UpsertStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `KV`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.KV))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `NS`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.NS))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `DB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.DB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt13 := z.Extension(z.I2Rtid(x.Data)); yyxt13 != nil {
						z.EncExtension(x.Data, yyxt13)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt14 := z.Extension(z.I2Rtid(x.Data)); yyxt14 != nil {
						z.EncExtension(x.Data, yyxt14)
					} 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(codecSelferCcUTF89697, `into`)
				r.WriteMapElemValue()
				if yyn15 {
					r.EncodeNil()
				} else {
					if x.Into == nil {
						r.EncodeNil()
					} else {
						x.Into.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt19 := z.Extension(z.I2Rtid(x.Echo)); yyxt19 != nil {
					z.EncExtension(x.Echo, yyxt19)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `echo`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt20 := z.Extension(z.I2Rtid(x.Echo)); yyxt20 != nil {
					z.EncExtension(x.Echo, yyxt20)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Echo)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Echo)
				} else {
					r.EncodeInt(int64(x.Echo))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt22 := z.Extension(z.I2Rtid(x.Timeout)); yyxt22 != nil {
					z.EncExtension(x.Timeout, yyxt22)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `timeout`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt23 := z.Extension(z.I2Rtid(x.Timeout)); yyxt23 != nil {
					z.EncExtension(x.Timeout, yyxt23)
				} else {
					r.EncodeInt(int64(x.Timeout))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeInt(int64(x.Parallel))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `parallel`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *UpsertStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "KV":
			if r.TryDecodeAsNil() {
				x.KV = ""
			} else {
				x.KV = (string)(r.DecodeString())
			}
		case "NS":
			if r.TryDecodeAsNil() {
				x.NS = ""
			} else {
				x.NS = (string)(r.DecodeString())
			}
		case "DB":
			if r.TryDecodeAsNil() {
				x.DB = ""
			} else {
				x.DB = (string)(r.DecodeString())
			}
		case "data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Data)); yyxt8 != nil {
					z.DecExtension(x.Data, yyxt8)
				} else {
					z.DecFallback(&x.Data, true)
				}
			}
		case "into":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Echo)); yyxt11 != nil {
					z.DecExtension(x.Echo, yyxt11)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Echo)
				} else {
					x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "timeout":
			if r.TryDecodeAsNil() {
				x.Timeout = 0
			} else {
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(x.Timeout)); yyxt13 != nil {
					z.DecExtension(x.Timeout, yyxt13)
				} else {
					x.Timeout = (time.Duration)(r.DecodeInt64())
				}
			}
		case "parallel":
			if r.TryDecodeAsNil() {
				x.Parallel = 0
			} else {
				x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *UpsertStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.KV = ""
	} else {
		x.KV = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.NS = ""
	} else {
		x.NS = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.DB = ""
	} else {
		x.DB = (string)(r.DecodeString())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Data = nil
	} else {
		if false {
		} else if yyxt20 := z.Extension(z.I2Rtid(x.Data)); yyxt20 != nil {
			z.DecExtension(x.Data, yyxt20)
		} else {
			z.DecFallback(&x.Data, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && x.Into != nil {
			x.Into = nil
		}
	} else {
		if x.Into == nil {
			x.Into = new(Table)
		}

		x.Into.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Echo = 0
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Echo)); yyxt23 != nil {
			z.DecExtension(x.Echo, yyxt23)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Echo)
		} else {
			x.Echo = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Timeout = 0
	} else {
		if false {
		} else if yyxt25 := z.Extension(z.I2Rtid(x.Timeout)); yyxt25 != nil {
			z.DecExtension(x.Timeout, yyxt25)
		} else {
			x.Timeout = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Parallel = 0
	} else {
		x.Parallel = (int)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize9697))
	}
	for {
		yyj15++
		if yyhl15 {
			yyb15 = yyj15 > l
		} else {
			yyb15 = r.CheckBreak()
		}
		if yyb15 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj15-1, "")
	}
	r.ReadArrayEnd()
}

func (x *DefineNamespaceStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineNamespaceStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveNamespaceStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineDatabaseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveDatabaseStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt4 := z.Extension(z.I2Rtid(x.Kind)); yyxt4 != nil {
					z.EncExtension(x.Kind, yyxt4)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `kind`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.EncExtension(x.Kind, yyxt5)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					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(codecSelferCcUTF89697, `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 {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Pass))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `pass`)
				r.WriteMapElemValue()
				if x.Pass == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Pass))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineLoginStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineLoginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.DecExtension(x.Kind, yyxt5)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Kind)
				} else {
					x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "user":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else {
					x.Pass = r.DecodeBytes(([]byte)(x.Pass), false)
				}
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				if false {
				} else {
					x.Code = r.DecodeBytes(([]byte)(x.Code), 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt13 := z.Extension(z.I2Rtid(x.Kind)); yyxt13 != nil {
			z.DecExtension(x.Kind, yyxt13)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Kind)
		} else {
			x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj11++
	if yyhl11 {
		yyb11 = yyj11 > l
	} else {
		yyb11 = r.CheckBreak()
	}
	if yyb11 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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 {
		if false {
		} else {
			x.Pass = r.DecodeBytes(([]byte)(x.Pass), 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 {
		if false {
		} else {
			x.Code = r.DecodeBytes(([]byte)(x.Code), 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt4 := z.Extension(z.I2Rtid(x.Kind)); yyxt4 != nil {
					z.EncExtension(x.Kind, yyxt4)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `kind`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.EncExtension(x.Kind, yyxt5)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveLoginStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.DecExtension(x.Kind, yyxt5)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Kind)
				} else {
					x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "user":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt9 := z.Extension(z.I2Rtid(x.Kind)); yyxt9 != nil {
			z.DecExtension(x.Kind, yyxt9)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Kind)
		} else {
			x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt4 := z.Extension(z.I2Rtid(x.Kind)); yyxt4 != nil {
					z.EncExtension(x.Kind, yyxt4)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `kind`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.EncExtension(x.Kind, yyxt5)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					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(codecSelferCcUTF89697, `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 false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Type))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `type`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Type))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineTokenStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineTokenStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.DecExtension(x.Kind, yyxt5)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Kind)
				} else {
					x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				x.Type = (string)(r.DecodeString())
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				if false {
				} else {
					x.Code = r.DecodeBytes(([]byte)(x.Code), 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 codecSelfer9697
	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.Kind = 0
	} else {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.Kind)); yyxt12 != nil {
			z.DecExtension(x.Kind, yyxt12)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Kind)
		} else {
			x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}

		x.Name.CodecDecodeSelf(d)
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = (string)(r.DecodeString())
	}
	yyj10++
	if yyhl10 {
		yyb10 = yyj10 > l
	} else {
		yyb10 = r.CheckBreak()
	}
	if yyb10 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Code = nil
	} else {
		if false {
		} else {
			x.Code = r.DecodeBytes(([]byte)(x.Code), 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 *RemoveTokenStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt4 := z.Extension(z.I2Rtid(x.Kind)); yyxt4 != nil {
					z.EncExtension(x.Kind, yyxt4)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Kind)
				} else {
					r.EncodeInt(int64(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `kind`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.EncExtension(x.Kind, yyxt5)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Kind)
				} else if !z.EncBinary() {
					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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveTokenStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = 0
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Kind)); yyxt5 != nil {
					z.DecExtension(x.Kind, yyxt5)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Kind)
				} else {
					x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt9 := z.Extension(z.I2Rtid(x.Kind)); yyxt9 != nil {
			z.DecExtension(x.Kind, yyxt9)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Kind)
		} else {
			x.Kind = (Token)(z.C.IntV(r.DecodeInt64(), 16))
		}
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(8)
			} else {
				r.WriteMapStart(8)
			}
			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(codecSelferCcUTF89697, `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 false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Time)); yyxt7 != nil {
					z.EncExtension(x.Time, yyxt7)
				} else {
					r.EncodeInt(int64(x.Time))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `time`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Time)); yyxt8 != nil {
					z.EncExtension(x.Time, yyxt8)
				} else {
					r.EncodeInt(int64(x.Time))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `code`)
				r.WriteMapElemValue()
				if x.Code == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						r.EncodeStringBytes(codecSelferCcRAW9697, []byte(x.Code))
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Signup == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt13 := z.Extension(z.I2Rtid(x.Signup)); yyxt13 != nil {
						z.EncExtension(x.Signup, yyxt13)
					} else {
						z.EncFallback(x.Signup)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `signup`)
				r.WriteMapElemValue()
				if x.Signup == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt14 := z.Extension(z.I2Rtid(x.Signup)); yyxt14 != nil {
						z.EncExtension(x.Signup, yyxt14)
					} else {
						z.EncFallback(x.Signup)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Signin == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt16 := z.Extension(z.I2Rtid(x.Signin)); yyxt16 != nil {
						z.EncExtension(x.Signin, yyxt16)
					} else {
						z.EncFallback(x.Signin)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `signin`)
				r.WriteMapElemValue()
				if x.Signin == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt17 := z.Extension(z.I2Rtid(x.Signin)); yyxt17 != nil {
						z.EncExtension(x.Signin, yyxt17)
					} else {
						z.EncFallback(x.Signin)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Connect == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt19 := z.Extension(z.I2Rtid(x.Connect)); yyxt19 != nil {
						z.EncExtension(x.Connect, yyxt19)
					} else {
						z.EncFallback(x.Connect)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `connect`)
				r.WriteMapElemValue()
				if x.Connect == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt20 := z.Extension(z.I2Rtid(x.Connect)); yyxt20 != nil {
						z.EncExtension(x.Connect, yyxt20)
					} else {
						z.EncFallback(x.Connect)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.OnSignup == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt22 := z.Extension(z.I2Rtid(x.OnSignup)); yyxt22 != nil {
						z.EncExtension(x.OnSignup, yyxt22)
					} else {
						z.EncFallback(x.OnSignup)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `onsignup`)
				r.WriteMapElemValue()
				if x.OnSignup == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt23 := z.Extension(z.I2Rtid(x.OnSignup)); yyxt23 != nil {
						z.EncExtension(x.OnSignup, yyxt23)
					} else {
						z.EncFallback(x.OnSignup)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.OnSignin == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt25 := z.Extension(z.I2Rtid(x.OnSignin)); yyxt25 != nil {
						z.EncExtension(x.OnSignin, yyxt25)
					} else {
						z.EncFallback(x.OnSignin)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `onsignin`)
				r.WriteMapElemValue()
				if x.OnSignin == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt26 := z.Extension(z.I2Rtid(x.OnSignin)); yyxt26 != nil {
						z.EncExtension(x.OnSignin, yyxt26)
					} else {
						z.EncFallback(x.OnSignin)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineScopeStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineScopeStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt6 := z.Extension(z.I2Rtid(x.Time)); yyxt6 != nil {
					z.DecExtension(x.Time, yyxt6)
				} else {
					x.Time = (time.Duration)(r.DecodeInt64())
				}
			}
		case "code":
			if r.TryDecodeAsNil() {
				x.Code = nil
			} else {
				if false {
				} else {
					x.Code = r.DecodeBytes(([]byte)(x.Code), false)
				}
			}
		case "signup":
			if r.TryDecodeAsNil() {
				x.Signup = nil
			} else {
				if false {
				} else if yyxt10 := z.Extension(z.I2Rtid(x.Signup)); yyxt10 != nil {
					z.DecExtension(x.Signup, yyxt10)
				} else {
					z.DecFallback(&x.Signup, true)
				}
			}
		case "signin":
			if r.TryDecodeAsNil() {
				x.Signin = nil
			} else {
				if false {
				} else if yyxt12 := z.Extension(z.I2Rtid(x.Signin)); yyxt12 != nil {
					z.DecExtension(x.Signin, yyxt12)
				} else {
					z.DecFallback(&x.Signin, true)
				}
			}
		case "connect":
			if r.TryDecodeAsNil() {
				x.Connect = nil
			} else {
				if false {
				} else if yyxt14 := z.Extension(z.I2Rtid(x.Connect)); yyxt14 != nil {
					z.DecExtension(x.Connect, yyxt14)
				} else {
					z.DecFallback(&x.Connect, true)
				}
			}
		case "onsignup":
			if r.TryDecodeAsNil() {
				x.OnSignup = nil
			} else {
				if false {
				} else if yyxt16 := z.Extension(z.I2Rtid(x.OnSignup)); yyxt16 != nil {
					z.DecExtension(x.OnSignup, yyxt16)
				} else {
					z.DecFallback(&x.OnSignup, true)
				}
			}
		case "onsignin":
			if r.TryDecodeAsNil() {
				x.OnSignin = nil
			} else {
				if false {
				} else if yyxt18 := z.Extension(z.I2Rtid(x.OnSignin)); yyxt18 != nil {
					z.DecExtension(x.OnSignin, yyxt18)
				} else {
					z.DecFallback(&x.OnSignin, 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 codecSelfer9697
	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() {
		if true && x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}

		x.Name.CodecDecodeSelf(d)
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Time = 0
	} else {
		if false {
		} else if yyxt22 := z.Extension(z.I2Rtid(x.Time)); yyxt22 != nil {
			z.DecExtension(x.Time, yyxt22)
		} else {
			x.Time = (time.Duration)(r.DecodeInt64())
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Code = nil
	} else {
		if false {
		} else {
			x.Code = r.DecodeBytes(([]byte)(x.Code), false)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Signup = nil
	} else {
		if false {
		} else if yyxt26 := z.Extension(z.I2Rtid(x.Signup)); yyxt26 != nil {
			z.DecExtension(x.Signup, yyxt26)
		} else {
			z.DecFallback(&x.Signup, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Signin = nil
	} else {
		if false {
		} else if yyxt28 := z.Extension(z.I2Rtid(x.Signin)); yyxt28 != nil {
			z.DecExtension(x.Signin, yyxt28)
		} else {
			z.DecFallback(&x.Signin, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Connect = nil
	} else {
		if false {
		} else if yyxt30 := z.Extension(z.I2Rtid(x.Connect)); yyxt30 != nil {
			z.DecExtension(x.Connect, yyxt30)
		} else {
			z.DecFallback(&x.Connect, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.OnSignup = nil
	} else {
		if false {
		} else if yyxt32 := z.Extension(z.I2Rtid(x.OnSignup)); yyxt32 != nil {
			z.DecExtension(x.OnSignup, yyxt32)
		} else {
			z.DecFallback(&x.OnSignup, true)
		}
	}
	yyj19++
	if yyhl19 {
		yyb19 = yyj19 > l
	} else {
		yyb19 = r.CheckBreak()
	}
	if yyb19 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.OnSignin = nil
	} else {
		if false {
		} else if yyxt34 := z.Extension(z.I2Rtid(x.OnSignin)); yyxt34 != nil {
			z.DecExtension(x.OnSignin, yyxt34)
		} else {
			z.DecFallback(&x.OnSignin, true)
		}
	}
	for {
		yyj19++
		if yyhl19 {
			yyb19 = yyj19 > l
		} else {
			yyb19 = r.CheckBreak()
		}
		if yyb19 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj19-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveScopeStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveScopeStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 codecSelfer9697
	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() {
		if true && 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 false {
				} else {
					r.EncodeBool(bool(x.Full))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `full`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeBool(bool(x.Full))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Drop))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `drop`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeBool(bool(x.Drop))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Lock))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `lock`)
				r.WriteMapElemValue()
				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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt22 := z.Extension(z.I2Rtid(x.Cond)); yyxt22 != nil {
						z.EncExtension(x.Cond, yyxt22)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt23 := z.Extension(z.I2Rtid(x.Cond)); yyxt23 != nil {
						z.EncExtension(x.Cond, yyxt23)
					} 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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt28 := z.Extension(z.I2Rtid(x.Perms)); yyxt28 != nil {
						z.EncExtension(x.Perms, yyxt28)
					} else {
						z.EncFallback(x.Perms)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `perms`)
				r.WriteMapElemValue()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt29 := z.Extension(z.I2Rtid(x.Perms)); yyxt29 != nil {
						z.EncExtension(x.Perms, yyxt29)
					} else {
						z.EncFallback(x.Perms)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineTableStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineTableStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				x.Full = (bool)(r.DecodeBool())
			}
		case "drop":
			if r.TryDecodeAsNil() {
				x.Drop = false
			} else {
				x.Drop = (bool)(r.DecodeBool())
			}
		case "lock":
			if r.TryDecodeAsNil() {
				x.Lock = false
			} else {
				x.Lock = (bool)(r.DecodeBool())
			}
		case "expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				x.Expr.CodecDecodeSelf(d)
			}
		case "from":
			if r.TryDecodeAsNil() {
				x.From = nil
			} else {
				x.From.CodecDecodeSelf(d)
			}
		case "cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Cond)); yyxt11 != nil {
					z.DecExtension(x.Cond, yyxt11)
				} else {
					z.DecFallback(&x.Cond, true)
				}
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Group = nil
			} else {
				x.Group.CodecDecodeSelf(d)
			}
		case "perms":
			if r.TryDecodeAsNil() {
				x.Perms = nil
			} else {
				if false {
				} else if yyxt14 := z.Extension(z.I2Rtid(x.Perms)); yyxt14 != nil {
					z.DecExtension(x.Perms, yyxt14)
				} else {
					z.DecFallback(&x.Perms, 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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj15 int
	var yyb15 bool
	var yyhl15 bool = l >= 0
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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.Full = false
	} else {
		x.Full = (bool)(r.DecodeBool())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Drop = false
	} else {
		x.Drop = (bool)(r.DecodeBool())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Lock = false
	} else {
		x.Lock = (bool)(r.DecodeBool())
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		x.Expr.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.From = nil
	} else {
		x.From.CodecDecodeSelf(d)
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cond = nil
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Cond)); yyxt23 != nil {
			z.DecExtension(x.Cond, yyxt23)
		} else {
			z.DecFallback(&x.Cond, true)
		}
	}
	yyj15++
	if yyhl15 {
		yyb15 = yyj15 > l
	} else {
		yyb15 = r.CheckBreak()
	}
	if yyb15 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Group = nil
	} else {
		x.Group.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 {
		if false {
		} else if yyxt26 := z.Extension(z.I2Rtid(x.Perms)); yyxt26 != nil {
			z.DecExtension(x.Perms, yyxt26)
		} else {
			z.DecFallback(&x.Perms, 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 *RemoveTableStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveTableStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt7 := z.Extension(z.I2Rtid(x.When)); yyxt7 != nil {
						z.EncExtension(x.When, yyxt7)
					} else {
						z.EncFallback(x.When)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `when`)
				r.WriteMapElemValue()
				if x.When == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt8 := z.Extension(z.I2Rtid(x.When)); yyxt8 != nil {
						z.EncExtension(x.When, yyxt8)
					} else {
						z.EncFallback(x.When)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.Then)); yyxt10 != nil {
						z.EncExtension(x.Then, yyxt10)
					} else {
						z.EncFallback(x.Then)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `then`)
				r.WriteMapElemValue()
				if x.Then == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.Then)); yyxt11 != nil {
						z.EncExtension(x.Then, yyxt11)
					} else {
						z.EncFallback(x.Then)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineEventStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineEventStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt6 := z.Extension(z.I2Rtid(x.When)); yyxt6 != nil {
					z.DecExtension(x.When, yyxt6)
				} else {
					z.DecFallback(&x.When, true)
				}
			}
		case "then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Then)); yyxt8 != nil {
					z.DecExtension(x.Then, yyxt8)
				} else {
					z.DecFallback(&x.Then, 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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj9 int
	var yyb9 bool
	var yyhl9 bool = l >= 0
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.When)); yyxt12 != nil {
			z.DecExtension(x.When, yyxt12)
		} else {
			z.DecFallback(&x.When, 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 {
		if false {
		} else if yyxt14 := z.Extension(z.I2Rtid(x.Then)); yyxt14 != nil {
			z.DecExtension(x.Then, yyxt14)
		} else {
			z.DecFallback(&x.Then, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveEventStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(7)
			} else {
				r.WriteMapStart(7)
			}
			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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt7 := z.Extension(z.I2Rtid(x.Perms)); yyxt7 != nil {
						z.EncExtension(x.Perms, yyxt7)
					} else {
						z.EncFallback(x.Perms)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `perms`)
				r.WriteMapElemValue()
				if x.Perms == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt8 := z.Extension(z.I2Rtid(x.Perms)); yyxt8 != nil {
						z.EncExtension(x.Perms, yyxt8)
					} else {
						z.EncFallback(x.Perms)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Type))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `type`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Type))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Kind))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `kind`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Kind))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Value == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt16 := z.Extension(z.I2Rtid(x.Value)); yyxt16 != nil {
						z.EncExtension(x.Value, yyxt16)
					} else {
						z.EncFallback(x.Value)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `value`)
				r.WriteMapElemValue()
				if x.Value == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt17 := z.Extension(z.I2Rtid(x.Value)); yyxt17 != nil {
						z.EncExtension(x.Value, yyxt17)
					} else {
						z.EncFallback(x.Value)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Assert == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt19 := z.Extension(z.I2Rtid(x.Assert)); yyxt19 != nil {
						z.EncExtension(x.Assert, yyxt19)
					} else {
						z.EncFallback(x.Assert)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `assert`)
				r.WriteMapElemValue()
				if x.Assert == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt20 := z.Extension(z.I2Rtid(x.Assert)); yyxt20 != nil {
						z.EncExtension(x.Assert, yyxt20)
					} else {
						z.EncFallback(x.Assert)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.Priority))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `priority`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeFloat64(float64(x.Priority))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DefineFieldStatement) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineFieldStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt6 := z.Extension(z.I2Rtid(x.Perms)); yyxt6 != nil {
					z.DecExtension(x.Perms, yyxt6)
				} else {
					z.DecFallback(&x.Perms, true)
				}
			}
		case "type":
			if r.TryDecodeAsNil() {
				x.Type = ""
			} else {
				x.Type = (string)(r.DecodeString())
			}
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = (string)(r.DecodeString())
			}
		case "value":
			if r.TryDecodeAsNil() {
				x.Value = nil
			} else {
				if false {
				} else if yyxt10 := z.Extension(z.I2Rtid(x.Value)); yyxt10 != nil {
					z.DecExtension(x.Value, yyxt10)
				} else {
					z.DecFallback(&x.Value, true)
				}
			}
		case "assert":
			if r.TryDecodeAsNil() {
				x.Assert = nil
			} else {
				if false {
				} else if yyxt12 := z.Extension(z.I2Rtid(x.Assert)); yyxt12 != nil {
					z.DecExtension(x.Assert, yyxt12)
				} else {
					z.DecFallback(&x.Assert, true)
				}
			}
		case "priority":
			if r.TryDecodeAsNil() {
				x.Priority = 0
			} else {
				x.Priority = (float64)(r.DecodeFloat64())
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *DefineFieldStatement) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj14 int
	var yyb14 bool
	var yyhl14 bool = l >= 0
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}

		x.Name.CodecDecodeSelf(d)
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Perms = nil
	} else {
		if false {
		} else if yyxt17 := z.Extension(z.I2Rtid(x.Perms)); yyxt17 != nil {
			z.DecExtension(x.Perms, yyxt17)
		} else {
			z.DecFallback(&x.Perms, true)
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Type = ""
	} else {
		x.Type = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = (string)(r.DecodeString())
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Value = nil
	} else {
		if false {
		} else if yyxt21 := z.Extension(z.I2Rtid(x.Value)); yyxt21 != nil {
			z.DecExtension(x.Value, yyxt21)
		} else {
			z.DecFallback(&x.Value, true)
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Assert = nil
	} else {
		if false {
		} else if yyxt23 := z.Extension(z.I2Rtid(x.Assert)); yyxt23 != nil {
			z.DecExtension(x.Assert, yyxt23)
		} else {
			z.DecFallback(&x.Assert, true)
		}
	}
	yyj14++
	if yyhl14 {
		yyb14 = yyj14 > l
	} else {
		yyb14 = r.CheckBreak()
	}
	if yyb14 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Priority = 0
	} else {
		x.Priority = (float64)(r.DecodeFloat64())
	}
	for {
		yyj14++
		if yyhl14 {
			yyb14 = yyj14 > l
		} else {
			yyb14 = r.CheckBreak()
		}
		if yyb14 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj14-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveFieldStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveFieldStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `cols`)
				r.WriteMapElemValue()
				if x.Cols == nil {
					r.EncodeNil()
				} else {
					x.Cols.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Uniq))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `uniq`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DefineIndexStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				x.Cols.CodecDecodeSelf(d)
			}
		case "uniq":
			if r.TryDecodeAsNil() {
				x.Uniq = false
			} else {
				x.Uniq = (bool)(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 codecSelfer9697
	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() {
		if true && x.Name != nil {
			x.Name = nil
		}
	} else {
		if x.Name == nil {
			x.Name = new(Ident)
		}

		x.Name.CodecDecodeSelf(d)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Cols = nil
	} else {
		x.Cols.CodecDecodeSelf(d)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Uniq = false
	} else {
		x.Uniq = (bool)(r.DecodeBool())
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x *RemoveIndexStatement) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *RemoveIndexStatement) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encExprs((Exprs)(x), e)
		}
	}
}

func (x *Exprs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decExprs((*Exprs)(x), d)
	}
}

func (x *All) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *All) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Any) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 *Null) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(0)
			} else {
				r.WriteMapStart(0)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Null) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Null) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Null) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Void) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Empty) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		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 codecSelfer9697
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Expr)); yyxt4 != nil {
						z.EncExtension(x.Expr, yyxt4)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
						z.EncExtension(x.Expr, yyxt5)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Field))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Field`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Field))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Alias))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Alias`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Alias))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Field) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Field) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
					z.DecExtension(x.Expr, yyxt5)
				} else {
					z.DecFallback(&x.Expr, true)
				}
			}
		case "Field":
			if r.TryDecodeAsNil() {
				x.Field = ""
			} else {
				x.Field = (string)(r.DecodeString())
			}
		case "Alias":
			if r.TryDecodeAsNil() {
				x.Alias = ""
			} else {
				x.Alias = (string)(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 codecSelfer9697
	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.Expr = nil
	} else {
		if false {
		} else if yyxt10 := z.Extension(z.I2Rtid(x.Expr)); yyxt10 != nil {
			z.DecExtension(x.Expr, yyxt10)
		} else {
			z.DecFallback(&x.Expr, true)
		}
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Field = ""
	} else {
		x.Field = (string)(r.DecodeString())
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Alias = ""
	} else {
		x.Alias = (string)(r.DecodeString())
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x Fields) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encFields((Fields)(x), e)
		}
	}
}

func (x *Fields) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decFields((*Fields)(x), d)
	}
}

func (x *Group) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Expr)); yyxt4 != nil {
						z.EncExtension(x.Expr, yyxt4)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
						z.EncExtension(x.Expr, yyxt5)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Group) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Group) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
					z.DecExtension(x.Expr, yyxt5)
				} else {
					z.DecFallback(&x.Expr, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Expr)); yyxt8 != nil {
			z.DecExtension(x.Expr, yyxt8)
		} else {
			z.DecFallback(&x.Expr, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encGroups((Groups)(x), e)
		}
	}
}

func (x *Groups) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decGroups((*Groups)(x), d)
	}
}

func (x *Order) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Expr)); yyxt4 != nil {
						z.EncExtension(x.Expr, yyxt4)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
						z.EncExtension(x.Expr, yyxt5)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Dir))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Dir`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeBool(bool(x.Dir))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				yy10 := &x.Tag
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(yy10)); yyxt11 != nil {
					z.EncExtension(yy10, yyxt11)
				} else if !z.EncBinary() {
					z.EncTextMarshal(yy10)
				} else {
					z.EncFallback(yy10)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Tag`)
				r.WriteMapElemValue()
				yy12 := &x.Tag
				if false {
				} else if yyxt13 := z.Extension(z.I2Rtid(yy12)); yyxt13 != nil {
					z.EncExtension(yy12, yyxt13)
				} else if !z.EncBinary() {
					z.EncTextMarshal(yy12)
				} else {
					z.EncFallback(yy12)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Order) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Order) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
					z.DecExtension(x.Expr, yyxt5)
				} else {
					z.DecFallback(&x.Expr, true)
				}
			}
		case "Dir":
			if r.TryDecodeAsNil() {
				x.Dir = false
			} else {
				x.Dir = (bool)(r.DecodeBool())
			}
		case "Tag":
			if r.TryDecodeAsNil() {
				x.Tag = pkg1_language.Tag{}
			} else {
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Tag)); yyxt8 != nil {
					z.DecExtension(x.Tag, yyxt8)
				} else if !z.DecBinary() {
					z.DecTextUnmarshal(&x.Tag)
				} else {
					z.DecFallback(&x.Tag, 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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj9 int
	var yyb9 bool
	var yyhl9 bool = l >= 0
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Expr = nil
	} else {
		if false {
		} else if yyxt11 := z.Extension(z.I2Rtid(x.Expr)); yyxt11 != nil {
			z.DecExtension(x.Expr, yyxt11)
		} else {
			z.DecFallback(&x.Expr, true)
		}
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Dir = false
	} else {
		x.Dir = (bool)(r.DecodeBool())
	}
	yyj9++
	if yyhl9 {
		yyb9 = yyj9 > l
	} else {
		yyb9 = r.CheckBreak()
	}
	if yyb9 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Tag = pkg1_language.Tag{}
	} else {
		if false {
		} else if yyxt14 := z.Extension(z.I2Rtid(x.Tag)); yyxt14 != nil {
			z.DecExtension(x.Tag, yyxt14)
		} else if !z.DecBinary() {
			z.DecTextUnmarshal(&x.Tag)
		} else {
			z.DecFallback(&x.Tag, false)
		}
	}
	for {
		yyj9++
		if yyhl9 {
			yyb9 = yyj9 > l
		} else {
			yyb9 = r.CheckBreak()
		}
		if yyb9 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj9-1, "")
	}
	r.ReadArrayEnd()
}

func (x Orders) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encOrders((Orders)(x), e)
		}
	}
}

func (x *Orders) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decOrders((*Orders)(x), d)
	}
}

func (x *SubExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Expr)); yyxt4 != nil {
						z.EncExtension(x.Expr, yyxt4)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
						z.EncExtension(x.Expr, yyxt5)
					} else {
						z.EncFallback(x.Expr)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *SubExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *SubExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Expr)); yyxt5 != nil {
					z.DecExtension(x.Expr, yyxt5)
				} else {
					z.DecFallback(&x.Expr, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Expr)); yyxt8 != nil {
			z.DecExtension(x.Expr, yyxt8)
		} else {
			z.DecFallback(&x.Expr, 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 *MultExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						h.encSliceExpr(([]Expr)(x.Expr), e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Expr`)
				r.WriteMapElemValue()
				if x.Expr == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						h.encSliceExpr(([]Expr)(x.Expr), e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *MultExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *MultExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				if false {
				} else {
					h.decSliceExpr((*[]Expr)(&x.Expr), d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *MultExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 {
		if false {
		} else {
			h.decSliceExpr((*[]Expr)(&x.Expr), 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 *IfelExpression) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.Else)); yyxt10 != nil {
						z.EncExtension(x.Else, yyxt10)
					} else {
						z.EncFallback(x.Else)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Else`)
				r.WriteMapElemValue()
				if x.Else == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.Else)); yyxt11 != nil {
						z.EncExtension(x.Else, yyxt11)
					} else {
						z.EncFallback(x.Else)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *IfelExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *IfelExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Cond":
			if r.TryDecodeAsNil() {
				x.Cond = nil
			} else {
				x.Cond.CodecDecodeSelf(d)
			}
		case "Then":
			if r.TryDecodeAsNil() {
				x.Then = nil
			} else {
				x.Then.CodecDecodeSelf(d)
			}
		case "Else":
			if r.TryDecodeAsNil() {
				x.Else = nil
			} else {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Else)); yyxt7 != nil {
					z.DecExtension(x.Else, yyxt7)
				} else {
					z.DecFallback(&x.Else, 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 codecSelfer9697
	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 {
		x.Cond.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 {
		x.Then.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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.Else)); yyxt12 != nil {
			z.DecExtension(x.Else, yyxt12)
		} else {
			z.DecFallback(&x.Else, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Name))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Name`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.Name))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Args == nil {
					r.EncodeNil()
				} else {
					x.Args.CodecEncodeSelf(e)
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Args`)
				r.WriteMapElemValue()
				if x.Args == nil {
					r.EncodeNil()
				} else {
					x.Args.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeBool(bool(x.Aggr))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Aggr`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeBool(bool(x.Aggr))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *FuncExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *FuncExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = (string)(r.DecodeString())
			}
		case "Args":
			if r.TryDecodeAsNil() {
				x.Args = nil
			} else {
				x.Args.CodecDecodeSelf(d)
			}
		case "Aggr":
			if r.TryDecodeAsNil() {
				x.Aggr = false
			} else {
				x.Aggr = (bool)(r.DecodeBool())
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *FuncExpression) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 {
		x.Name = (string)(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 {
		x.Args.CodecDecodeSelf(d)
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.Aggr = false
	} else {
		x.Aggr = (bool)(r.DecodeBool())
	}
	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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.LHS)); yyxt4 != nil {
						z.EncExtension(x.LHS, yyxt4)
					} else {
						z.EncFallback(x.LHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `LHS`)
				r.WriteMapElemValue()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.LHS)); yyxt5 != nil {
						z.EncExtension(x.LHS, yyxt5)
					} else {
						z.EncFallback(x.LHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Op)); yyxt7 != nil {
					z.EncExtension(x.Op, yyxt7)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Op)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Op`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Op)); yyxt8 != nil {
					z.EncExtension(x.Op, yyxt8)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Op)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.RHS)); yyxt10 != nil {
						z.EncExtension(x.RHS, yyxt10)
					} else {
						z.EncFallback(x.RHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `RHS`)
				r.WriteMapElemValue()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.RHS)); yyxt11 != nil {
						z.EncExtension(x.RHS, yyxt11)
					} else {
						z.EncFallback(x.RHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *ItemExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *ItemExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "LHS":
			if r.TryDecodeAsNil() {
				x.LHS = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.LHS)); yyxt5 != nil {
					z.DecExtension(x.LHS, yyxt5)
				} else {
					z.DecFallback(&x.LHS, true)
				}
			}
		case "Op":
			if r.TryDecodeAsNil() {
				x.Op = 0
			} else {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Op)); yyxt7 != nil {
					z.DecExtension(x.Op, yyxt7)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Op)
				} else {
					x.Op = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "RHS":
			if r.TryDecodeAsNil() {
				x.RHS = nil
			} else {
				if false {
				} else if yyxt9 := z.Extension(z.I2Rtid(x.RHS)); yyxt9 != nil {
					z.DecExtension(x.RHS, yyxt9)
				} else {
					z.DecFallback(&x.RHS, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.LHS)); yyxt12 != nil {
			z.DecExtension(x.LHS, yyxt12)
		} else {
			z.DecFallback(&x.LHS, 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 {
		if false {
		} else if yyxt14 := z.Extension(z.I2Rtid(x.Op)); yyxt14 != nil {
			z.DecExtension(x.Op, yyxt14)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Op)
		} else {
			x.Op = (Token)(z.C.IntV(r.DecodeInt64(), 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 {
		if false {
		} else if yyxt16 := z.Extension(z.I2Rtid(x.RHS)); yyxt16 != nil {
			z.DecExtension(x.RHS, yyxt16)
		} else {
			z.DecFallback(&x.RHS, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(3)
			} else {
				r.WriteMapStart(3)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.LHS)); yyxt4 != nil {
						z.EncExtension(x.LHS, yyxt4)
					} else {
						z.EncFallback(x.LHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `LHS`)
				r.WriteMapElemValue()
				if x.LHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.LHS)); yyxt5 != nil {
						z.EncExtension(x.LHS, yyxt5)
					} else {
						z.EncFallback(x.LHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Op)); yyxt7 != nil {
					z.EncExtension(x.Op, yyxt7)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Op)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Op`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt8 := z.Extension(z.I2Rtid(x.Op)); yyxt8 != nil {
					z.EncExtension(x.Op, yyxt8)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Op)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Op)
				} else {
					r.EncodeInt(int64(x.Op))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.RHS)); yyxt10 != nil {
						z.EncExtension(x.RHS, yyxt10)
					} else {
						z.EncFallback(x.RHS)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `RHS`)
				r.WriteMapElemValue()
				if x.RHS == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.RHS)); yyxt11 != nil {
						z.EncExtension(x.RHS, yyxt11)
					} else {
						z.EncFallback(x.RHS)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *BinaryExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *BinaryExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "LHS":
			if r.TryDecodeAsNil() {
				x.LHS = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.LHS)); yyxt5 != nil {
					z.DecExtension(x.LHS, yyxt5)
				} else {
					z.DecFallback(&x.LHS, true)
				}
			}
		case "Op":
			if r.TryDecodeAsNil() {
				x.Op = 0
			} else {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Op)); yyxt7 != nil {
					z.DecExtension(x.Op, yyxt7)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Op)
				} else {
					x.Op = (Token)(z.C.IntV(r.DecodeInt64(), 16))
				}
			}
		case "RHS":
			if r.TryDecodeAsNil() {
				x.RHS = nil
			} else {
				if false {
				} else if yyxt9 := z.Extension(z.I2Rtid(x.RHS)); yyxt9 != nil {
					z.DecExtension(x.RHS, yyxt9)
				} else {
					z.DecFallback(&x.RHS, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.LHS)); yyxt12 != nil {
			z.DecExtension(x.LHS, yyxt12)
		} else {
			z.DecFallback(&x.LHS, 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 {
		if false {
		} else if yyxt14 := z.Extension(z.I2Rtid(x.Op)); yyxt14 != nil {
			z.DecExtension(x.Op, yyxt14)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Op)
		} else {
			x.Op = (Token)(z.C.IntV(r.DecodeInt64(), 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 {
		if false {
		} else if yyxt16 := z.Extension(z.I2Rtid(x.RHS)); yyxt16 != nil {
			z.DecExtension(x.RHS, yyxt16)
		} else {
			z.DecFallback(&x.RHS, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *PathExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Expr":
			if r.TryDecodeAsNil() {
				x.Expr = nil
			} else {
				x.Expr.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 codecSelfer9697
	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 {
		x.Expr.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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Part == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Part)); yyxt4 != nil {
						z.EncExtension(x.Part, yyxt4)
					} else {
						z.EncFallback(x.Part)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Part`)
				r.WriteMapElemValue()
				if x.Part == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Part)); yyxt5 != nil {
						z.EncExtension(x.Part, yyxt5)
					} else {
						z.EncFallback(x.Part)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *PartExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *PartExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Part":
			if r.TryDecodeAsNil() {
				x.Part = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Part)); yyxt5 != nil {
					z.DecExtension(x.Part, yyxt5)
				} else {
					z.DecFallback(&x.Part, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Part)); yyxt8 != nil {
			z.DecExtension(x.Part, yyxt8)
		} else {
			z.DecFallback(&x.Part, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else if yyxt4 := z.Extension(z.I2Rtid(x.Join)); yyxt4 != nil {
					z.EncExtension(x.Join, yyxt4)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Join)
				} else if !z.EncBinary() {
					z.EncTextMarshal(x.Join)
				} else {
					r.EncodeInt(int64(x.Join))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Join`)
				r.WriteMapElemValue()
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Join)); yyxt5 != nil {
					z.EncExtension(x.Join, yyxt5)
				} else if z.EncBinary() {
					z.EncBinaryMarshal(x.Join)
				} else if !z.EncBinary() {
					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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *JoinExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Join":
			if r.TryDecodeAsNil() {
				x.Join = 0
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Join)); yyxt5 != nil {
					z.DecExtension(x.Join, yyxt5)
				} else if z.DecBinary() {
					z.DecBinaryUnmarshal(&x.Join)
				} else {
					x.Join = (Token)(z.C.IntV(r.DecodeInt64(), 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Join)); yyxt8 != nil {
			z.DecExtension(x.Join, yyxt8)
		} else if z.DecBinary() {
			z.DecBinaryUnmarshal(&x.Join)
		} else {
			x.Join = (Token)(z.C.IntV(r.DecodeInt64(), 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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(codecSelferCcUTF89697, `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 {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.Cond)); yyxt10 != nil {
						z.EncExtension(x.Cond, yyxt10)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Cond`)
				r.WriteMapElemValue()
				if x.Cond == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.Cond)); yyxt11 != nil {
						z.EncExtension(x.Cond, yyxt11)
					} else {
						z.EncFallback(x.Cond)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *SubpExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *SubpExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "What":
			if r.TryDecodeAsNil() {
				x.What = nil
			} else {
				x.What.CodecDecodeSelf(d)
			}
		case "Name":
			if r.TryDecodeAsNil() {
				if true && 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 {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Cond)); yyxt7 != nil {
					z.DecExtension(x.Cond, yyxt7)
				} else {
					z.DecFallback(&x.Cond, 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 codecSelfer9697
	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 {
		x.What.CodecDecodeSelf(d)
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		if true && 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 {
		if false {
		} else if yyxt12 := z.Extension(z.I2Rtid(x.Cond)); yyxt12 != nil {
			z.DecExtension(x.Cond, yyxt12)
		} else {
			z.DecFallback(&x.Cond, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Select == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Select)); yyxt4 != nil {
						z.EncExtension(x.Select, yyxt4)
					} else {
						z.EncFallback(x.Select)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Select`)
				r.WriteMapElemValue()
				if x.Select == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Select)); yyxt5 != nil {
						z.EncExtension(x.Select, yyxt5)
					} else {
						z.EncFallback(x.Select)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Create == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt7 := z.Extension(z.I2Rtid(x.Create)); yyxt7 != nil {
						z.EncExtension(x.Create, yyxt7)
					} else {
						z.EncFallback(x.Create)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Create`)
				r.WriteMapElemValue()
				if x.Create == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt8 := z.Extension(z.I2Rtid(x.Create)); yyxt8 != nil {
						z.EncExtension(x.Create, yyxt8)
					} else {
						z.EncFallback(x.Create)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Update == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt10 := z.Extension(z.I2Rtid(x.Update)); yyxt10 != nil {
						z.EncExtension(x.Update, yyxt10)
					} else {
						z.EncFallback(x.Update)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Update`)
				r.WriteMapElemValue()
				if x.Update == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt11 := z.Extension(z.I2Rtid(x.Update)); yyxt11 != nil {
						z.EncExtension(x.Update, yyxt11)
					} else {
						z.EncFallback(x.Update)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Delete == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt13 := z.Extension(z.I2Rtid(x.Delete)); yyxt13 != nil {
						z.EncExtension(x.Delete, yyxt13)
					} else {
						z.EncFallback(x.Delete)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Delete`)
				r.WriteMapElemValue()
				if x.Delete == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt14 := z.Extension(z.I2Rtid(x.Delete)); yyxt14 != nil {
						z.EncExtension(x.Delete, yyxt14)
					} else {
						z.EncFallback(x.Delete)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *PermExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *PermExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Select":
			if r.TryDecodeAsNil() {
				x.Select = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Select)); yyxt5 != nil {
					z.DecExtension(x.Select, yyxt5)
				} else {
					z.DecFallback(&x.Select, true)
				}
			}
		case "Create":
			if r.TryDecodeAsNil() {
				x.Create = nil
			} else {
				if false {
				} else if yyxt7 := z.Extension(z.I2Rtid(x.Create)); yyxt7 != nil {
					z.DecExtension(x.Create, yyxt7)
				} else {
					z.DecFallback(&x.Create, true)
				}
			}
		case "Update":
			if r.TryDecodeAsNil() {
				x.Update = nil
			} else {
				if false {
				} else if yyxt9 := z.Extension(z.I2Rtid(x.Update)); yyxt9 != nil {
					z.DecExtension(x.Update, yyxt9)
				} else {
					z.DecFallback(&x.Update, true)
				}
			}
		case "Delete":
			if r.TryDecodeAsNil() {
				x.Delete = nil
			} else {
				if false {
				} else if yyxt11 := z.Extension(z.I2Rtid(x.Delete)); yyxt11 != nil {
					z.DecExtension(x.Delete, yyxt11)
				} else {
					z.DecFallback(&x.Delete, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt14 := z.Extension(z.I2Rtid(x.Select)); yyxt14 != nil {
			z.DecExtension(x.Select, yyxt14)
		} else {
			z.DecFallback(&x.Select, 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 {
		if false {
		} else if yyxt16 := z.Extension(z.I2Rtid(x.Create)); yyxt16 != nil {
			z.DecExtension(x.Create, yyxt16)
		} else {
			z.DecFallback(&x.Create, 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 {
		if false {
		} else if yyxt18 := z.Extension(z.I2Rtid(x.Update)); yyxt18 != nil {
			z.DecExtension(x.Update, yyxt18)
		} else {
			z.DecFallback(&x.Update, 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 {
		if false {
		} else if yyxt20 := z.Extension(z.I2Rtid(x.Delete)); yyxt20 != nil {
			z.DecExtension(x.Delete, yyxt20)
		} else {
			z.DecFallback(&x.Delete, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						h.encSlicePtrtoItemExpression(([]*ItemExpression)(x.Data), e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DataExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else {
					h.decSlicePtrtoItemExpression((*[]*ItemExpression)(&x.Data), 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 codecSelfer9697
	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 {
		if false {
		} else {
			h.decSlicePtrtoItemExpression((*[]*ItemExpression)(&x.Data), 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Data)); yyxt4 != nil {
						z.EncExtension(x.Data, yyxt4)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
						z.EncExtension(x.Data, yyxt5)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *DiffExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *DiffExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
					z.DecExtension(x.Data, yyxt5)
				} else {
					z.DecFallback(&x.Data, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Data)); yyxt8 != nil {
			z.DecExtension(x.Data, yyxt8)
		} else {
			z.DecFallback(&x.Data, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Data)); yyxt4 != nil {
						z.EncExtension(x.Data, yyxt4)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
						z.EncExtension(x.Data, yyxt5)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *MergeExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *MergeExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
					z.DecExtension(x.Data, yyxt5)
				} else {
					z.DecFallback(&x.Data, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Data)); yyxt8 != nil {
			z.DecExtension(x.Data, yyxt8)
		} else {
			z.DecFallback(&x.Data, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt4 := z.Extension(z.I2Rtid(x.Data)); yyxt4 != nil {
						z.EncExtension(x.Data, yyxt4)
					} else {
						z.EncFallback(x.Data)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `Data`)
				r.WriteMapElemValue()
				if x.Data == nil {
					r.EncodeNil()
				} else {
					if false {
					} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
						z.EncExtension(x.Data, yyxt5)
					} else {
						z.EncFallback(x.Data)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *ContentExpression) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *ContentExpression) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "Data":
			if r.TryDecodeAsNil() {
				x.Data = nil
			} else {
				if false {
				} else if yyxt5 := z.Extension(z.I2Rtid(x.Data)); yyxt5 != nil {
					z.DecExtension(x.Data, yyxt5)
				} else {
					z.DecFallback(&x.Data, 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 codecSelfer9697
	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 {
		if false {
		} else if yyxt8 := z.Extension(z.I2Rtid(x.Data)); yyxt8 != nil {
			z.DecExtension(x.Data, yyxt8)
		} else {
			z.DecFallback(&x.Data, 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 codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(4)
			} else {
				r.WriteMapStart(4)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `TB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.MIN))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `MIN`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeFloat64(float64(x.MIN))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.INC))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `INC`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeFloat64(float64(x.INC))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.MAX))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `MAX`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Model) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				x.TB = (string)(r.DecodeString())
			}
		case "MIN":
			if r.TryDecodeAsNil() {
				x.MIN = 0
			} else {
				x.MIN = (float64)(r.DecodeFloat64())
			}
		case "INC":
			if r.TryDecodeAsNil() {
				x.INC = 0
			} else {
				x.INC = (float64)(r.DecodeFloat64())
			}
		case "MAX":
			if r.TryDecodeAsNil() {
				x.MAX = 0
			} else {
				x.MAX = (float64)(r.DecodeFloat64())
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Model) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 {
		x.TB = (string)(r.DecodeString())
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.MIN = 0
	} else {
		x.MIN = (float64)(r.DecodeFloat64())
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.INC = 0
	} else {
		x.INC = (float64)(r.DecodeFloat64())
	}
	yyj8++
	if yyhl8 {
		yyb8 = yyj8 > l
	} else {
		yyb8 = r.CheckBreak()
	}
	if yyb8 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.MAX = 0
	} else {
		x.MAX = (float64)(r.DecodeFloat64())
	}
	for {
		yyj8++
		if yyhl8 {
			yyb8 = yyj8 > l
		} else {
			yyb8 = r.CheckBreak()
		}
		if yyb8 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj8-1, "")
	}
	r.ReadArrayEnd()
}

func (x Params) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encParams((Params)(x), e)
		}
	}
}

func (x *Params) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decParams((*Params)(x), d)
	}
}

func (x *Param) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `ID`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Param) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Param) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				x.ID = (string)(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 codecSelfer9697
	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.ID = ""
	} else {
		x.ID = (string)(r.DecodeString())
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x Values) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encValues((Values)(x), e)
		}
	}
}

func (x *Values) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decValues((*Values)(x), d)
	}
}

func (x *Value) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `ID`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Value) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Value) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				x.ID = (string)(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 codecSelfer9697
	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.ID = ""
	} else {
		x.ID = (string)(r.DecodeString())
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x Idents) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encIdents((Idents)(x), e)
		}
	}
}

func (x *Idents) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decIdents((*Idents)(x), d)
	}
}

func (x *Ident) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `ID`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.ID))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Ident) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Ident) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = ""
			} else {
				x.ID = (string)(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 codecSelfer9697
	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.ID = ""
	} else {
		x.ID = (string)(r.DecodeString())
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x Tables) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encTables((Tables)(x), e)
		}
	}
}

func (x *Tables) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decTables((*Tables)(x), d)
	}
}

func (x *Table) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(1)
			} else {
				r.WriteMapStart(1)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `TB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Table) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Table) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				x.TB = (string)(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 codecSelfer9697
	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.TB = ""
	} else {
		x.TB = (string)(r.DecodeString())
	}
	for {
		yyj5++
		if yyhl5 {
			yyb5 = yyj5 > l
		} else {
			yyb5 = r.CheckBreak()
		}
		if yyb5 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj5-1, "")
	}
	r.ReadArrayEnd()
}

func (x Batchs) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encBatchs((Batchs)(x), e)
		}
	}
}

func (x *Batchs) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decBatchs((*Batchs)(x), d)
	}
}

func (x *Batch) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `TB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.BA == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						h.encSlicePtrtoThing(([]*Thing)(x.BA), e)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `BA`)
				r.WriteMapElemValue()
				if x.BA == nil {
					r.EncodeNil()
				} else {
					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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Batch) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				x.TB = (string)(r.DecodeString())
			}
		case "BA":
			if r.TryDecodeAsNil() {
				x.BA = nil
			} else {
				if false {
				} else {
					h.decSlicePtrtoThing((*[]*Thing)(&x.BA), 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 codecSelfer9697
	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.TB = ""
	} else {
		x.TB = (string)(r.DecodeString())
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.BA = nil
	} else {
		if false {
		} else {
			h.decSlicePtrtoThing((*[]*Thing)(&x.BA), 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 Things) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encThings((Things)(x), e)
		}
	}
}

func (x *Things) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decThings((*Things)(x), d)
	}
}

func (x *Thing) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() {
			z.EncTextMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `TB`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeString(codecSelferCcUTF89697, string(x.TB))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if x.ID == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						z.EncFallback(x.ID)
					}
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `ID`)
				r.WriteMapElemValue()
				if x.ID == nil {
					r.EncodeNil()
				} else {
					if false {
					} else {
						z.EncFallback(x.ID)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayEnd()
			} else {
				r.WriteMapEnd()
			}
		}
	}
}

func (x *Thing) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Thing) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "TB":
			if r.TryDecodeAsNil() {
				x.TB = ""
			} else {
				x.TB = (string)(r.DecodeString())
			}
		case "ID":
			if r.TryDecodeAsNil() {
				x.ID = nil
			} else {
				if false {
				} else {
					z.DecFallback(&x.ID, 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 codecSelfer9697
	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.TB = ""
	} else {
		x.TB = (string)(r.DecodeString())
	}
	yyj7++
	if yyhl7 {
		yyb7 = yyj7 > l
	} else {
		yyb7 = r.CheckBreak()
	}
	if yyb7 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.ID = nil
	} else {
		if false {
		} else {
			z.DecFallback(&x.ID, true)
		}
	}
	for {
		yyj7++
		if yyhl7 {
			yyb7 = yyj7 > l
		} else {
			yyb7 = r.CheckBreak()
		}
		if yyb7 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj7-1, "")
	}
	r.ReadArrayEnd()
}

func (x Points) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encPoints((Points)(x), e)
		}
	}
}

func (x *Points) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decPoints((*Points)(x), d)
	}
}

func (x *Point) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			if yyr2 || yy2arr2 {
				r.WriteArrayStart(2)
			} else {
				r.WriteMapStart(2)
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.LA))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `LA`)
				r.WriteMapElemValue()
				if false {
				} else {
					r.EncodeFloat64(float64(x.LA))
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.LO))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `LO`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Point) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "LA":
			if r.TryDecodeAsNil() {
				x.LA = 0
			} else {
				x.LA = (float64)(r.DecodeFloat64())
			}
		case "LO":
			if r.TryDecodeAsNil() {
				x.LO = 0
			} else {
				x.LO = (float64)(r.DecodeFloat64())
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Point) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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.LA = 0
	} else {
		x.LA = (float64)(r.DecodeFloat64())
	}
	yyj6++
	if yyhl6 {
		yyb6 = yyj6 > l
	} else {
		yyb6 = r.CheckBreak()
	}
	if yyb6 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.LO = 0
	} else {
		x.LO = (float64)(r.DecodeFloat64())
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Circles) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encCircles((Circles)(x), e)
		}
	}
}

func (x *Circles) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decCircles((*Circles)(x), d)
	}
}

func (x *Circle) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `CE`)
				r.WriteMapElemValue()
				if yyn3 {
					r.EncodeNil()
				} else {
					if x.CE == nil {
						r.EncodeNil()
					} else {
						x.CE.CodecEncodeSelf(e)
					}
				}
			}
			if yyr2 || yy2arr2 {
				r.WriteArrayElem()
				if false {
				} else {
					r.EncodeFloat64(float64(x.RA))
				}
			} else {
				r.WriteMapElemKey()
				r.EncodeString(codecSelferCcUTF89697, `RA`)
				r.WriteMapElemValue()
				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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Circle) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "CE":
			if r.TryDecodeAsNil() {
				if true && 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 {
				x.RA = (float64)(r.DecodeFloat64())
			}
		default:
			z.DecStructFieldNotFound(-1, yys3)
		} // end switch yys3
	} // end for yyj3
	r.ReadMapEnd()
}

func (x *Circle) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	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() {
		if true && x.CE != nil {
			x.CE = nil
		}
	} else {
		if x.CE == nil {
			x.CE = new(Point)
		}

		x.CE.CodecDecodeSelf(d)
	}
	yyj6++
	if yyhl6 {
		yyb6 = yyj6 > l
	} else {
		yyb6 = r.CheckBreak()
	}
	if yyb6 {
		r.ReadArrayEnd()
		return
	}
	r.ReadArrayElem()
	if r.TryDecodeAsNil() {
		x.RA = 0
	} else {
		x.RA = (float64)(r.DecodeFloat64())
	}
	for {
		yyj6++
		if yyhl6 {
			yyb6 = yyj6 > l
		} else {
			yyb6 = r.CheckBreak()
		}
		if yyb6 {
			break
		}
		r.ReadArrayElem()
		z.DecStructFieldNotFound(yyj6-1, "")
	}
	r.ReadArrayEnd()
}

func (x Polygons) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else {
			h.encPolygons((Polygons)(x), e)
		}
	}
}

func (x *Polygons) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		h.decPolygons((*Polygons)(x), d)
	}
}

func (x *Polygon) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		if false {
		} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
			z.EncExtension(x, yyxt1)
		} else if !z.EncBinary() && z.IsJSONHandle() {
			z.EncJSONMarshal(x)
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			_, _ = yysep2, yy2arr2
			const yyr2 bool = false // struct tag has 'toArray'
			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(codecSelferCcUTF89697, `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 codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	if false {
	} else if yyxt1 := z.Extension(z.I2Rtid(x)); yyxt1 != nil {
		z.DecExtension(x, yyxt1)
	} else {
		yyct2 := r.ContainerType()
		if yyct2 == codecSelferValueTypeMap9697 {
			yyl2 := r.ReadMapStart()
			if yyl2 == 0 {
				r.ReadMapEnd()
			} else {
				x.codecDecodeSelfFromMap(yyl2, d)
			}
		} else if yyct2 == codecSelferValueTypeArray9697 {
			yyl2 := r.ReadArrayStart()
			if yyl2 == 0 {
				r.ReadArrayEnd()
			} else {
				x.codecDecodeSelfFromArray(yyl2, d)
			}
		} else {
			panic(errCodecSelferOnlyMapOrArrayEncodeToStruct9697)
		}
	}
}

func (x *Polygon) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyhl3 bool = l >= 0
	for yyj3 := 0; ; yyj3++ {
		if yyhl3 {
			if yyj3 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		r.ReadMapElemKey()
		yys3 := z.StringView(r.DecodeStringAsBytes())
		r.ReadMapElemValue()
		switch yys3 {
		case "PS":
			if r.TryDecodeAsNil() {
				x.PS = nil
			} else {
				x.PS.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 codecSelfer9697
	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 {
		x.PS.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 codecSelfer9697) encStatements(v Statements, e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			if false {
			} else if yyxt2 := z.Extension(z.I2Rtid(yyv1)); yyxt2 != nil {
				z.EncExtension(yyv1, yyxt2)
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer9697) decStatements(v *Statements, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]Statement, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if false {
					} else if yyxt3 := z.Extension(z.I2Rtid(yyv1[yyj1])); yyxt3 != nil {
						z.DecExtension(yyv1[yyj1], yyxt3)
					} else {
						z.DecFallback(&yyv1[yyj1], 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 codecSelfer9697) encExprs(v Exprs, e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			if false {
			} else if yyxt2 := z.Extension(z.I2Rtid(yyv1)); yyxt2 != nil {
				z.EncExtension(yyv1, yyxt2)
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer9697) decExprs(v *Exprs, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]Expr, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if false {
					} else if yyxt3 := z.Extension(z.I2Rtid(yyv1[yyj1])); yyxt3 != nil {
						z.DecExtension(yyv1[yyj1], yyxt3)
					} else {
						z.DecFallback(&yyv1[yyj1], 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 codecSelfer9697) encFields(v Fields, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decFields(v *Fields, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Field, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Field)
					}
					yyv1[yyj1].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 codecSelfer9697) encGroups(v Groups, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decGroups(v *Groups, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Group, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Group)
					}
					yyv1[yyj1].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 codecSelfer9697) encOrders(v Orders, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decOrders(v *Orders, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Order, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Order)
					}
					yyv1[yyj1].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 codecSelfer9697) encSliceExpr(v []Expr, e *codec1978.Encoder) {
	var h codecSelfer9697
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	r.WriteArrayStart(len(v))
	for _, yyv1 := range v {
		r.WriteArrayElem()
		if yyv1 == nil {
			r.EncodeNil()
		} else {
			if false {
			} else if yyxt2 := z.Extension(z.I2Rtid(yyv1)); yyxt2 != nil {
				z.EncExtension(yyv1, yyxt2)
			} else {
				z.EncFallback(yyv1)
			}
		}
	}
	r.WriteArrayEnd()
}

func (x codecSelfer9697) decSliceExpr(v *[]Expr, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]Expr, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if false {
					} else if yyxt3 := z.Extension(z.I2Rtid(yyv1[yyj1])); yyxt3 != nil {
						z.DecExtension(yyv1[yyj1], yyxt3)
					} else {
						z.DecFallback(&yyv1[yyj1], 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 codecSelfer9697) encSlicePtrtoItemExpression(v []*ItemExpression, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decSlicePtrtoItemExpression(v *[]*ItemExpression, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*ItemExpression, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(ItemExpression)
					}
					yyv1[yyj1].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 codecSelfer9697) encParams(v Params, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decParams(v *Params, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Param, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Param)
					}
					yyv1[yyj1].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 codecSelfer9697) encValues(v Values, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decValues(v *Values, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Value, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Value)
					}
					yyv1[yyj1].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 codecSelfer9697) encIdents(v Idents, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decIdents(v *Idents, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Ident, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Ident)
					}
					yyv1[yyj1].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 codecSelfer9697) encTables(v Tables, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decTables(v *Tables, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Table, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Table)
					}
					yyv1[yyj1].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 codecSelfer9697) encBatchs(v Batchs, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decBatchs(v *Batchs, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Batch, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Batch)
					}
					yyv1[yyj1].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 codecSelfer9697) encSlicePtrtoThing(v []*Thing, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decSlicePtrtoThing(v *[]*Thing, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Thing, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Thing)
					}
					yyv1[yyj1].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 codecSelfer9697) encThings(v Things, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decThings(v *Things, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Thing, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Thing)
					}
					yyv1[yyj1].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 codecSelfer9697) encPoints(v Points, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decPoints(v *Points, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Point, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Point)
					}
					yyv1[yyj1].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 codecSelfer9697) encCircles(v Circles, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decCircles(v *Circles, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Circle, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Circle)
					}
					yyv1[yyj1].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 codecSelfer9697) encPolygons(v Polygons, e *codec1978.Encoder) {
	var h codecSelfer9697
	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 codecSelfer9697) decPolygons(v *Polygons, d *codec1978.Decoder) {
	var h codecSelfer9697
	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 && yyv1 == nil {
				if yyhl1 {
					yyrl1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
				} else {
					yyrl1 = 8
				}
				yyv1 = make([]*Polygon, yyrl1)
				yyc1 = true
			}
			yyh1.ElemContainerState(yyj1)

			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 {
					if yyv1[yyj1] == nil {
						yyv1[yyj1] = new(Polygon)
					}
					yyv1[yyj1].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
	}
}