package godoc

import (
	"go/ast"
	"go/token"
	"golang.org/x/pkgsite/internal/godoc/codec"
)

func encode_ast_ArrayType(e *codec.Encoder, x *ast.ArrayType) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Lbrack != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Lbrack))
	}
	if x.Len != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Len)
	}
	if x.Elt != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Elt)
	}
	e.EndStruct()
}

func decode_ast_ArrayType(d *codec.Decoder, p **ast.ArrayType) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ArrayType)
		return
	}
	var x ast.ArrayType
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Lbrack = token.Pos(d.DecodeInt())
		case 1:
			x.Len = d.DecodeAny().(ast.Expr)
		case 2:
			x.Elt = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.ArrayType", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ArrayType{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ArrayType(e, x.(*ast.ArrayType)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ArrayType
			decode_ast_ArrayType(d, &x)
			return x
		})
}

func encode_ast_AssignStmt(e *codec.Encoder, x *ast.AssignStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Lhs != nil {
		e.EncodeUint(0)
		encode_slice_ast_Expr(e, x.Lhs)
	}
	if x.TokPos != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.TokPos))
	}
	if x.Tok != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Tok))
	}
	if x.Rhs != nil {
		e.EncodeUint(3)
		encode_slice_ast_Expr(e, x.Rhs)
	}
	e.EndStruct()
}

func decode_ast_AssignStmt(d *codec.Decoder, p **ast.AssignStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.AssignStmt)
		return
	}
	var x ast.AssignStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_slice_ast_Expr(d, &x.Lhs)
		case 1:
			x.TokPos = token.Pos(d.DecodeInt())
		case 2:
			x.Tok = token.Token(d.DecodeInt())
		case 3:
			decode_slice_ast_Expr(d, &x.Rhs)
		default:
			d.UnknownField("ast.AssignStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.AssignStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_AssignStmt(e, x.(*ast.AssignStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.AssignStmt
			decode_ast_AssignStmt(d, &x)
			return x
		})
}

func encode_ast_BadDecl(e *codec.Encoder, x *ast.BadDecl) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.From != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.From))
	}
	if x.To != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.To))
	}
	e.EndStruct()
}

func decode_ast_BadDecl(d *codec.Decoder, p **ast.BadDecl) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BadDecl)
		return
	}
	var x ast.BadDecl
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.From = token.Pos(d.DecodeInt())
		case 1:
			x.To = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.BadDecl", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BadDecl{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BadDecl(e, x.(*ast.BadDecl)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BadDecl
			decode_ast_BadDecl(d, &x)
			return x
		})
}

func encode_ast_BadExpr(e *codec.Encoder, x *ast.BadExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.From != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.From))
	}
	if x.To != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.To))
	}
	e.EndStruct()
}

func decode_ast_BadExpr(d *codec.Decoder, p **ast.BadExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BadExpr)
		return
	}
	var x ast.BadExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.From = token.Pos(d.DecodeInt())
		case 1:
			x.To = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.BadExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BadExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BadExpr(e, x.(*ast.BadExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BadExpr
			decode_ast_BadExpr(d, &x)
			return x
		})
}

func encode_ast_BadStmt(e *codec.Encoder, x *ast.BadStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.From != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.From))
	}
	if x.To != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.To))
	}
	e.EndStruct()
}

func decode_ast_BadStmt(d *codec.Decoder, p **ast.BadStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BadStmt)
		return
	}
	var x ast.BadStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.From = token.Pos(d.DecodeInt())
		case 1:
			x.To = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.BadStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BadStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BadStmt(e, x.(*ast.BadStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BadStmt
			decode_ast_BadStmt(d, &x)
			return x
		})
}

func encode_ast_BasicLit(e *codec.Encoder, x *ast.BasicLit) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.ValuePos != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.ValuePos))
	}
	if x.Kind != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Kind))
	}
	if x.Value != "" {
		e.EncodeUint(2)
		e.EncodeString(x.Value)
	}
	e.EndStruct()
}

func decode_ast_BasicLit(d *codec.Decoder, p **ast.BasicLit) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BasicLit)
		return
	}
	var x ast.BasicLit
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.ValuePos = token.Pos(d.DecodeInt())
		case 1:
			x.Kind = token.Token(d.DecodeInt())
		case 2:
			x.Value = d.DecodeString()
		default:
			d.UnknownField("ast.BasicLit", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BasicLit{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BasicLit(e, x.(*ast.BasicLit)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BasicLit
			decode_ast_BasicLit(d, &x)
			return x
		})
}

func encode_ast_BinaryExpr(e *codec.Encoder, x *ast.BinaryExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.X != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.X)
	}
	if x.OpPos != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.OpPos))
	}
	if x.Op != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Op))
	}
	if x.Y != nil {
		e.EncodeUint(3)
		e.EncodeAny(x.Y)
	}
	e.EndStruct()
}

func decode_ast_BinaryExpr(d *codec.Decoder, p **ast.BinaryExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BinaryExpr)
		return
	}
	var x ast.BinaryExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.X = d.DecodeAny().(ast.Expr)
		case 1:
			x.OpPos = token.Pos(d.DecodeInt())
		case 2:
			x.Op = token.Token(d.DecodeInt())
		case 3:
			x.Y = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.BinaryExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BinaryExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BinaryExpr(e, x.(*ast.BinaryExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BinaryExpr
			decode_ast_BinaryExpr(d, &x)
			return x
		})
}

func encode_ast_BlockStmt(e *codec.Encoder, x *ast.BlockStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Lbrace != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Lbrace))
	}
	if x.List != nil {
		e.EncodeUint(1)
		encode_slice_ast_Stmt(e, x.List)
	}
	if x.Rbrace != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Rbrace))
	}
	e.EndStruct()
}

func decode_ast_BlockStmt(d *codec.Decoder, p **ast.BlockStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BlockStmt)
		return
	}
	var x ast.BlockStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Lbrace = token.Pos(d.DecodeInt())
		case 1:
			decode_slice_ast_Stmt(d, &x.List)
		case 2:
			x.Rbrace = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.BlockStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BlockStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BlockStmt(e, x.(*ast.BlockStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BlockStmt
			decode_ast_BlockStmt(d, &x)
			return x
		})
}

func encode_ast_BranchStmt(e *codec.Encoder, x *ast.BranchStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.TokPos != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.TokPos))
	}
	if x.Tok != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Tok))
	}
	if x.Label != nil {
		e.EncodeUint(2)
		encode_ast_Ident(e, x.Label)
	}
	e.EndStruct()
}

func decode_ast_BranchStmt(d *codec.Decoder, p **ast.BranchStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.BranchStmt)
		return
	}
	var x ast.BranchStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.TokPos = token.Pos(d.DecodeInt())
		case 1:
			x.Tok = token.Token(d.DecodeInt())
		case 2:
			decode_ast_Ident(d, &x.Label)
		default:
			d.UnknownField("ast.BranchStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.BranchStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_BranchStmt(e, x.(*ast.BranchStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.BranchStmt
			decode_ast_BranchStmt(d, &x)
			return x
		})
}

func encode_ast_CallExpr(e *codec.Encoder, x *ast.CallExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Fun != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.Fun)
	}
	if x.Lparen != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Lparen))
	}
	if x.Args != nil {
		e.EncodeUint(2)
		encode_slice_ast_Expr(e, x.Args)
	}
	if x.Ellipsis != 0 {
		e.EncodeUint(3)
		e.EncodeInt(int64(x.Ellipsis))
	}
	if x.Rparen != 0 {
		e.EncodeUint(4)
		e.EncodeInt(int64(x.Rparen))
	}
	e.EndStruct()
}

func decode_ast_CallExpr(d *codec.Decoder, p **ast.CallExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.CallExpr)
		return
	}
	var x ast.CallExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Fun = d.DecodeAny().(ast.Expr)
		case 1:
			x.Lparen = token.Pos(d.DecodeInt())
		case 2:
			decode_slice_ast_Expr(d, &x.Args)
		case 3:
			x.Ellipsis = token.Pos(d.DecodeInt())
		case 4:
			x.Rparen = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.CallExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.CallExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_CallExpr(e, x.(*ast.CallExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.CallExpr
			decode_ast_CallExpr(d, &x)
			return x
		})
}

func encode_ast_CaseClause(e *codec.Encoder, x *ast.CaseClause) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Case != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Case))
	}
	if x.List != nil {
		e.EncodeUint(1)
		encode_slice_ast_Expr(e, x.List)
	}
	if x.Colon != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Colon))
	}
	if x.Body != nil {
		e.EncodeUint(3)
		encode_slice_ast_Stmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_CaseClause(d *codec.Decoder, p **ast.CaseClause) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.CaseClause)
		return
	}
	var x ast.CaseClause
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Case = token.Pos(d.DecodeInt())
		case 1:
			decode_slice_ast_Expr(d, &x.List)
		case 2:
			x.Colon = token.Pos(d.DecodeInt())
		case 3:
			decode_slice_ast_Stmt(d, &x.Body)
		default:
			d.UnknownField("ast.CaseClause", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.CaseClause{},
		func(e *codec.Encoder, x interface{}) { encode_ast_CaseClause(e, x.(*ast.CaseClause)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.CaseClause
			decode_ast_CaseClause(d, &x)
			return x
		})
}

func encode_ast_ChanType(e *codec.Encoder, x *ast.ChanType) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Begin != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Begin))
	}
	if x.Arrow != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Arrow))
	}
	if x.Dir != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Dir))
	}
	if x.Value != nil {
		e.EncodeUint(3)
		e.EncodeAny(x.Value)
	}
	e.EndStruct()
}

func decode_ast_ChanType(d *codec.Decoder, p **ast.ChanType) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ChanType)
		return
	}
	var x ast.ChanType
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Begin = token.Pos(d.DecodeInt())
		case 1:
			x.Arrow = token.Pos(d.DecodeInt())
		case 2:
			x.Dir = ast.ChanDir(d.DecodeInt())
		case 3:
			x.Value = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.ChanType", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ChanType{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ChanType(e, x.(*ast.ChanType)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ChanType
			decode_ast_ChanType(d, &x)
			return x
		})
}

func encode_ast_CommClause(e *codec.Encoder, x *ast.CommClause) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Case != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Case))
	}
	if x.Comm != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Comm)
	}
	if x.Colon != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Colon))
	}
	if x.Body != nil {
		e.EncodeUint(3)
		encode_slice_ast_Stmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_CommClause(d *codec.Decoder, p **ast.CommClause) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.CommClause)
		return
	}
	var x ast.CommClause
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Case = token.Pos(d.DecodeInt())
		case 1:
			x.Comm = d.DecodeAny().(ast.Stmt)
		case 2:
			x.Colon = token.Pos(d.DecodeInt())
		case 3:
			decode_slice_ast_Stmt(d, &x.Body)
		default:
			d.UnknownField("ast.CommClause", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.CommClause{},
		func(e *codec.Encoder, x interface{}) { encode_ast_CommClause(e, x.(*ast.CommClause)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.CommClause
			decode_ast_CommClause(d, &x)
			return x
		})
}

func encode_ast_CommentGroup(e *codec.Encoder, x *ast.CommentGroup) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.List != nil {
		e.EncodeUint(0)
		encode_slice_ast_Comment(e, x.List)
	}
	e.EndStruct()
}

func decode_ast_CommentGroup(d *codec.Decoder, p **ast.CommentGroup) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.CommentGroup)
		return
	}
	var x ast.CommentGroup
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_slice_ast_Comment(d, &x.List)
		default:
			d.UnknownField("ast.CommentGroup", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.CommentGroup{},
		func(e *codec.Encoder, x interface{}) { encode_ast_CommentGroup(e, x.(*ast.CommentGroup)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.CommentGroup
			decode_ast_CommentGroup(d, &x)
			return x
		})
}

func encode_ast_Comment(e *codec.Encoder, x *ast.Comment) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Slash != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Slash))
	}
	if x.Text != "" {
		e.EncodeUint(1)
		e.EncodeString(x.Text)
	}
	e.EndStruct()
}

func decode_ast_Comment(d *codec.Decoder, p **ast.Comment) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.Comment)
		return
	}
	var x ast.Comment
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Slash = token.Pos(d.DecodeInt())
		case 1:
			x.Text = d.DecodeString()
		default:
			d.UnknownField("ast.Comment", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.Comment{},
		func(e *codec.Encoder, x interface{}) { encode_ast_Comment(e, x.(*ast.Comment)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.Comment
			decode_ast_Comment(d, &x)
			return x
		})
}

func encode_ast_CompositeLit(e *codec.Encoder, x *ast.CompositeLit) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Type != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.Type)
	}
	if x.Lbrace != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Lbrace))
	}
	if x.Elts != nil {
		e.EncodeUint(2)
		encode_slice_ast_Expr(e, x.Elts)
	}
	if x.Rbrace != 0 {
		e.EncodeUint(3)
		e.EncodeInt(int64(x.Rbrace))
	}
	if x.Incomplete != false {
		e.EncodeUint(4)
		e.EncodeBool(x.Incomplete)
	}
	e.EndStruct()
}

func decode_ast_CompositeLit(d *codec.Decoder, p **ast.CompositeLit) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.CompositeLit)
		return
	}
	var x ast.CompositeLit
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Type = d.DecodeAny().(ast.Expr)
		case 1:
			x.Lbrace = token.Pos(d.DecodeInt())
		case 2:
			decode_slice_ast_Expr(d, &x.Elts)
		case 3:
			x.Rbrace = token.Pos(d.DecodeInt())
		case 4:
			x.Incomplete = d.DecodeBool()
		default:
			d.UnknownField("ast.CompositeLit", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.CompositeLit{},
		func(e *codec.Encoder, x interface{}) { encode_ast_CompositeLit(e, x.(*ast.CompositeLit)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.CompositeLit
			decode_ast_CompositeLit(d, &x)
			return x
		})
}

func encode_ast_DeclStmt(e *codec.Encoder, x *ast.DeclStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Decl != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.Decl)
	}
	e.EndStruct()
}

func decode_ast_DeclStmt(d *codec.Decoder, p **ast.DeclStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.DeclStmt)
		return
	}
	var x ast.DeclStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Decl = d.DecodeAny().(ast.Decl)
		default:
			d.UnknownField("ast.DeclStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.DeclStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_DeclStmt(e, x.(*ast.DeclStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.DeclStmt
			decode_ast_DeclStmt(d, &x)
			return x
		})
}

func encode_ast_DeferStmt(e *codec.Encoder, x *ast.DeferStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Defer != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Defer))
	}
	if x.Call != nil {
		e.EncodeUint(1)
		encode_ast_CallExpr(e, x.Call)
	}
	e.EndStruct()
}

func decode_ast_DeferStmt(d *codec.Decoder, p **ast.DeferStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.DeferStmt)
		return
	}
	var x ast.DeferStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Defer = token.Pos(d.DecodeInt())
		case 1:
			decode_ast_CallExpr(d, &x.Call)
		default:
			d.UnknownField("ast.DeferStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.DeferStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_DeferStmt(e, x.(*ast.DeferStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.DeferStmt
			decode_ast_DeferStmt(d, &x)
			return x
		})
}

func encode_ast_Ellipsis(e *codec.Encoder, x *ast.Ellipsis) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Ellipsis != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Ellipsis))
	}
	if x.Elt != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Elt)
	}
	e.EndStruct()
}

func decode_ast_Ellipsis(d *codec.Decoder, p **ast.Ellipsis) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.Ellipsis)
		return
	}
	var x ast.Ellipsis
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Ellipsis = token.Pos(d.DecodeInt())
		case 1:
			x.Elt = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.Ellipsis", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.Ellipsis{},
		func(e *codec.Encoder, x interface{}) { encode_ast_Ellipsis(e, x.(*ast.Ellipsis)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.Ellipsis
			decode_ast_Ellipsis(d, &x)
			return x
		})
}

func encode_ast_EmptyStmt(e *codec.Encoder, x *ast.EmptyStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Semicolon != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Semicolon))
	}
	if x.Implicit != false {
		e.EncodeUint(1)
		e.EncodeBool(x.Implicit)
	}
	e.EndStruct()
}

func decode_ast_EmptyStmt(d *codec.Decoder, p **ast.EmptyStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.EmptyStmt)
		return
	}
	var x ast.EmptyStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Semicolon = token.Pos(d.DecodeInt())
		case 1:
			x.Implicit = d.DecodeBool()
		default:
			d.UnknownField("ast.EmptyStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.EmptyStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_EmptyStmt(e, x.(*ast.EmptyStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.EmptyStmt
			decode_ast_EmptyStmt(d, &x)
			return x
		})
}

func encode_ast_ExprStmt(e *codec.Encoder, x *ast.ExprStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.X != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.X)
	}
	e.EndStruct()
}

func decode_ast_ExprStmt(d *codec.Decoder, p **ast.ExprStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ExprStmt)
		return
	}
	var x ast.ExprStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.X = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.ExprStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ExprStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ExprStmt(e, x.(*ast.ExprStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ExprStmt
			decode_ast_ExprStmt(d, &x)
			return x
		})
}

func encode_ast_FieldList(e *codec.Encoder, x *ast.FieldList) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Opening != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Opening))
	}
	if x.List != nil {
		e.EncodeUint(1)
		encode_slice_ast_Field(e, x.List)
	}
	if x.Closing != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Closing))
	}
	e.EndStruct()
}

func decode_ast_FieldList(d *codec.Decoder, p **ast.FieldList) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.FieldList)
		return
	}
	var x ast.FieldList
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Opening = token.Pos(d.DecodeInt())
		case 1:
			decode_slice_ast_Field(d, &x.List)
		case 2:
			x.Closing = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.FieldList", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.FieldList{},
		func(e *codec.Encoder, x interface{}) { encode_ast_FieldList(e, x.(*ast.FieldList)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.FieldList
			decode_ast_FieldList(d, &x)
			return x
		})
}

func encode_ast_Field(e *codec.Encoder, x *ast.Field) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Doc != nil {
		e.EncodeUint(0)
		encode_ast_CommentGroup(e, x.Doc)
	}
	if x.Names != nil {
		e.EncodeUint(1)
		encode_slice_ast_Ident(e, x.Names)
	}
	if x.Type != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Type)
	}
	if x.Tag != nil {
		e.EncodeUint(3)
		encode_ast_BasicLit(e, x.Tag)
	}
	if x.Comment != nil {
		e.EncodeUint(4)
		encode_ast_CommentGroup(e, x.Comment)
	}
	e.EndStruct()
}

func decode_ast_Field(d *codec.Decoder, p **ast.Field) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.Field)
		return
	}
	var x ast.Field
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_CommentGroup(d, &x.Doc)
		case 1:
			decode_slice_ast_Ident(d, &x.Names)
		case 2:
			x.Type = d.DecodeAny().(ast.Expr)
		case 3:
			decode_ast_BasicLit(d, &x.Tag)
		case 4:
			decode_ast_CommentGroup(d, &x.Comment)
		default:
			d.UnknownField("ast.Field", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.Field{},
		func(e *codec.Encoder, x interface{}) { encode_ast_Field(e, x.(*ast.Field)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.Field
			decode_ast_Field(d, &x)
			return x
		})
}

func encode_ast_ForStmt(e *codec.Encoder, x *ast.ForStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.For != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.For))
	}
	if x.Init != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Init)
	}
	if x.Cond != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Cond)
	}
	if x.Post != nil {
		e.EncodeUint(3)
		e.EncodeAny(x.Post)
	}
	if x.Body != nil {
		e.EncodeUint(4)
		encode_ast_BlockStmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_ForStmt(d *codec.Decoder, p **ast.ForStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ForStmt)
		return
	}
	var x ast.ForStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.For = token.Pos(d.DecodeInt())
		case 1:
			x.Init = d.DecodeAny().(ast.Stmt)
		case 2:
			x.Cond = d.DecodeAny().(ast.Expr)
		case 3:
			x.Post = d.DecodeAny().(ast.Stmt)
		case 4:
			decode_ast_BlockStmt(d, &x.Body)
		default:
			d.UnknownField("ast.ForStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ForStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ForStmt(e, x.(*ast.ForStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ForStmt
			decode_ast_ForStmt(d, &x)
			return x
		})
}

func encode_ast_FuncDecl(e *codec.Encoder, x *ast.FuncDecl) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Doc != nil {
		e.EncodeUint(0)
		encode_ast_CommentGroup(e, x.Doc)
	}
	if x.Recv != nil {
		e.EncodeUint(1)
		encode_ast_FieldList(e, x.Recv)
	}
	if x.Name != nil {
		e.EncodeUint(2)
		encode_ast_Ident(e, x.Name)
	}
	if x.Type != nil {
		e.EncodeUint(3)
		encode_ast_FuncType(e, x.Type)
	}
	if x.Body != nil {
		e.EncodeUint(4)
		encode_ast_BlockStmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_FuncDecl(d *codec.Decoder, p **ast.FuncDecl) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.FuncDecl)
		return
	}
	var x ast.FuncDecl
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_CommentGroup(d, &x.Doc)
		case 1:
			decode_ast_FieldList(d, &x.Recv)
		case 2:
			decode_ast_Ident(d, &x.Name)
		case 3:
			decode_ast_FuncType(d, &x.Type)
		case 4:
			decode_ast_BlockStmt(d, &x.Body)
		default:
			d.UnknownField("ast.FuncDecl", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.FuncDecl{},
		func(e *codec.Encoder, x interface{}) { encode_ast_FuncDecl(e, x.(*ast.FuncDecl)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.FuncDecl
			decode_ast_FuncDecl(d, &x)
			return x
		})
}

func encode_ast_FuncLit(e *codec.Encoder, x *ast.FuncLit) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Type != nil {
		e.EncodeUint(0)
		encode_ast_FuncType(e, x.Type)
	}
	if x.Body != nil {
		e.EncodeUint(1)
		encode_ast_BlockStmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_FuncLit(d *codec.Decoder, p **ast.FuncLit) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.FuncLit)
		return
	}
	var x ast.FuncLit
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_FuncType(d, &x.Type)
		case 1:
			decode_ast_BlockStmt(d, &x.Body)
		default:
			d.UnknownField("ast.FuncLit", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.FuncLit{},
		func(e *codec.Encoder, x interface{}) { encode_ast_FuncLit(e, x.(*ast.FuncLit)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.FuncLit
			decode_ast_FuncLit(d, &x)
			return x
		})
}

func encode_ast_FuncType(e *codec.Encoder, x *ast.FuncType) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Func != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Func))
	}
	if x.Params != nil {
		e.EncodeUint(1)
		encode_ast_FieldList(e, x.Params)
	}
	if x.Results != nil {
		e.EncodeUint(2)
		encode_ast_FieldList(e, x.Results)
	}
	e.EndStruct()
}

func decode_ast_FuncType(d *codec.Decoder, p **ast.FuncType) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.FuncType)
		return
	}
	var x ast.FuncType
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Func = token.Pos(d.DecodeInt())
		case 1:
			decode_ast_FieldList(d, &x.Params)
		case 2:
			decode_ast_FieldList(d, &x.Results)
		default:
			d.UnknownField("ast.FuncType", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.FuncType{},
		func(e *codec.Encoder, x interface{}) { encode_ast_FuncType(e, x.(*ast.FuncType)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.FuncType
			decode_ast_FuncType(d, &x)
			return x
		})
}

func encode_ast_GenDecl(e *codec.Encoder, x *ast.GenDecl) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Doc != nil {
		e.EncodeUint(0)
		encode_ast_CommentGroup(e, x.Doc)
	}
	if x.TokPos != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.TokPos))
	}
	if x.Tok != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Tok))
	}
	if x.Lparen != 0 {
		e.EncodeUint(3)
		e.EncodeInt(int64(x.Lparen))
	}
	if x.Specs != nil {
		e.EncodeUint(4)
		encode_slice_ast_Spec(e, x.Specs)
	}
	if x.Rparen != 0 {
		e.EncodeUint(5)
		e.EncodeInt(int64(x.Rparen))
	}
	e.EndStruct()
}

func decode_ast_GenDecl(d *codec.Decoder, p **ast.GenDecl) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.GenDecl)
		return
	}
	var x ast.GenDecl
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_CommentGroup(d, &x.Doc)
		case 1:
			x.TokPos = token.Pos(d.DecodeInt())
		case 2:
			x.Tok = token.Token(d.DecodeInt())
		case 3:
			x.Lparen = token.Pos(d.DecodeInt())
		case 4:
			decode_slice_ast_Spec(d, &x.Specs)
		case 5:
			x.Rparen = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.GenDecl", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.GenDecl{},
		func(e *codec.Encoder, x interface{}) { encode_ast_GenDecl(e, x.(*ast.GenDecl)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.GenDecl
			decode_ast_GenDecl(d, &x)
			return x
		})
}

func encode_ast_GoStmt(e *codec.Encoder, x *ast.GoStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Go != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Go))
	}
	if x.Call != nil {
		e.EncodeUint(1)
		encode_ast_CallExpr(e, x.Call)
	}
	e.EndStruct()
}

func decode_ast_GoStmt(d *codec.Decoder, p **ast.GoStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.GoStmt)
		return
	}
	var x ast.GoStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Go = token.Pos(d.DecodeInt())
		case 1:
			decode_ast_CallExpr(d, &x.Call)
		default:
			d.UnknownField("ast.GoStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.GoStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_GoStmt(e, x.(*ast.GoStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.GoStmt
			decode_ast_GoStmt(d, &x)
			return x
		})
}

func encode_ast_Ident(e *codec.Encoder, x *ast.Ident) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.NamePos != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.NamePos))
	}
	if x.Name != "" {
		e.EncodeUint(1)
		e.EncodeString(x.Name)
	}
	if x.Obj != nil {
		e.EncodeUint(2)
		encode_ast_Object(e, x.Obj)
	}
	e.EndStruct()
}

func decode_ast_Ident(d *codec.Decoder, p **ast.Ident) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.Ident)
		return
	}
	var x ast.Ident
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.NamePos = token.Pos(d.DecodeInt())
		case 1:
			x.Name = d.DecodeString()
		case 2:
			decode_ast_Object(d, &x.Obj)
		default:
			d.UnknownField("ast.Ident", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.Ident{},
		func(e *codec.Encoder, x interface{}) { encode_ast_Ident(e, x.(*ast.Ident)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.Ident
			decode_ast_Ident(d, &x)
			return x
		})
}

func encode_ast_IfStmt(e *codec.Encoder, x *ast.IfStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.If != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.If))
	}
	if x.Init != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Init)
	}
	if x.Cond != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Cond)
	}
	if x.Body != nil {
		e.EncodeUint(3)
		encode_ast_BlockStmt(e, x.Body)
	}
	if x.Else != nil {
		e.EncodeUint(4)
		e.EncodeAny(x.Else)
	}
	e.EndStruct()
}

func decode_ast_IfStmt(d *codec.Decoder, p **ast.IfStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.IfStmt)
		return
	}
	var x ast.IfStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.If = token.Pos(d.DecodeInt())
		case 1:
			x.Init = d.DecodeAny().(ast.Stmt)
		case 2:
			x.Cond = d.DecodeAny().(ast.Expr)
		case 3:
			decode_ast_BlockStmt(d, &x.Body)
		case 4:
			x.Else = d.DecodeAny().(ast.Stmt)
		default:
			d.UnknownField("ast.IfStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.IfStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_IfStmt(e, x.(*ast.IfStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.IfStmt
			decode_ast_IfStmt(d, &x)
			return x
		})
}

func encode_ast_ImportSpec(e *codec.Encoder, x *ast.ImportSpec) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Doc != nil {
		e.EncodeUint(0)
		encode_ast_CommentGroup(e, x.Doc)
	}
	if x.Name != nil {
		e.EncodeUint(1)
		encode_ast_Ident(e, x.Name)
	}
	if x.Path != nil {
		e.EncodeUint(2)
		encode_ast_BasicLit(e, x.Path)
	}
	if x.Comment != nil {
		e.EncodeUint(3)
		encode_ast_CommentGroup(e, x.Comment)
	}
	if x.EndPos != 0 {
		e.EncodeUint(4)
		e.EncodeInt(int64(x.EndPos))
	}
	e.EndStruct()
}

func decode_ast_ImportSpec(d *codec.Decoder, p **ast.ImportSpec) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ImportSpec)
		return
	}
	var x ast.ImportSpec
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_CommentGroup(d, &x.Doc)
		case 1:
			decode_ast_Ident(d, &x.Name)
		case 2:
			decode_ast_BasicLit(d, &x.Path)
		case 3:
			decode_ast_CommentGroup(d, &x.Comment)
		case 4:
			x.EndPos = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.ImportSpec", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ImportSpec{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ImportSpec(e, x.(*ast.ImportSpec)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ImportSpec
			decode_ast_ImportSpec(d, &x)
			return x
		})
}

func encode_ast_IncDecStmt(e *codec.Encoder, x *ast.IncDecStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.X != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.X)
	}
	if x.TokPos != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.TokPos))
	}
	if x.Tok != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Tok))
	}
	e.EndStruct()
}

func decode_ast_IncDecStmt(d *codec.Decoder, p **ast.IncDecStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.IncDecStmt)
		return
	}
	var x ast.IncDecStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.X = d.DecodeAny().(ast.Expr)
		case 1:
			x.TokPos = token.Pos(d.DecodeInt())
		case 2:
			x.Tok = token.Token(d.DecodeInt())
		default:
			d.UnknownField("ast.IncDecStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.IncDecStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_IncDecStmt(e, x.(*ast.IncDecStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.IncDecStmt
			decode_ast_IncDecStmt(d, &x)
			return x
		})
}

func encode_ast_IndexExpr(e *codec.Encoder, x *ast.IndexExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.X != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.X)
	}
	if x.Lbrack != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Lbrack))
	}
	if x.Index != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Index)
	}
	if x.Rbrack != 0 {
		e.EncodeUint(3)
		e.EncodeInt(int64(x.Rbrack))
	}
	e.EndStruct()
}

func decode_ast_IndexExpr(d *codec.Decoder, p **ast.IndexExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.IndexExpr)
		return
	}
	var x ast.IndexExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.X = d.DecodeAny().(ast.Expr)
		case 1:
			x.Lbrack = token.Pos(d.DecodeInt())
		case 2:
			x.Index = d.DecodeAny().(ast.Expr)
		case 3:
			x.Rbrack = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.IndexExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.IndexExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_IndexExpr(e, x.(*ast.IndexExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.IndexExpr
			decode_ast_IndexExpr(d, &x)
			return x
		})
}

func encode_ast_InterfaceType(e *codec.Encoder, x *ast.InterfaceType) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Interface != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Interface))
	}
	if x.Methods != nil {
		e.EncodeUint(1)
		encode_ast_FieldList(e, x.Methods)
	}
	if x.Incomplete != false {
		e.EncodeUint(2)
		e.EncodeBool(x.Incomplete)
	}
	e.EndStruct()
}

func decode_ast_InterfaceType(d *codec.Decoder, p **ast.InterfaceType) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.InterfaceType)
		return
	}
	var x ast.InterfaceType
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Interface = token.Pos(d.DecodeInt())
		case 1:
			decode_ast_FieldList(d, &x.Methods)
		case 2:
			x.Incomplete = d.DecodeBool()
		default:
			d.UnknownField("ast.InterfaceType", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.InterfaceType{},
		func(e *codec.Encoder, x interface{}) { encode_ast_InterfaceType(e, x.(*ast.InterfaceType)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.InterfaceType
			decode_ast_InterfaceType(d, &x)
			return x
		})
}

func encode_ast_KeyValueExpr(e *codec.Encoder, x *ast.KeyValueExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Key != nil {
		e.EncodeUint(0)
		e.EncodeAny(x.Key)
	}
	if x.Colon != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Colon))
	}
	if x.Value != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Value)
	}
	e.EndStruct()
}

func decode_ast_KeyValueExpr(d *codec.Decoder, p **ast.KeyValueExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.KeyValueExpr)
		return
	}
	var x ast.KeyValueExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Key = d.DecodeAny().(ast.Expr)
		case 1:
			x.Colon = token.Pos(d.DecodeInt())
		case 2:
			x.Value = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.KeyValueExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.KeyValueExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_KeyValueExpr(e, x.(*ast.KeyValueExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.KeyValueExpr
			decode_ast_KeyValueExpr(d, &x)
			return x
		})
}

func encode_ast_LabeledStmt(e *codec.Encoder, x *ast.LabeledStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Label != nil {
		e.EncodeUint(0)
		encode_ast_Ident(e, x.Label)
	}
	if x.Colon != 0 {
		e.EncodeUint(1)
		e.EncodeInt(int64(x.Colon))
	}
	if x.Stmt != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Stmt)
	}
	e.EndStruct()
}

func decode_ast_LabeledStmt(d *codec.Decoder, p **ast.LabeledStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.LabeledStmt)
		return
	}
	var x ast.LabeledStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_Ident(d, &x.Label)
		case 1:
			x.Colon = token.Pos(d.DecodeInt())
		case 2:
			x.Stmt = d.DecodeAny().(ast.Stmt)
		default:
			d.UnknownField("ast.LabeledStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.LabeledStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_LabeledStmt(e, x.(*ast.LabeledStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.LabeledStmt
			decode_ast_LabeledStmt(d, &x)
			return x
		})
}

func encode_ast_MapType(e *codec.Encoder, x *ast.MapType) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Map != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Map))
	}
	if x.Key != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Key)
	}
	if x.Value != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Value)
	}
	e.EndStruct()
}

func decode_ast_MapType(d *codec.Decoder, p **ast.MapType) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.MapType)
		return
	}
	var x ast.MapType
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Map = token.Pos(d.DecodeInt())
		case 1:
			x.Key = d.DecodeAny().(ast.Expr)
		case 2:
			x.Value = d.DecodeAny().(ast.Expr)
		default:
			d.UnknownField("ast.MapType", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.MapType{},
		func(e *codec.Encoder, x interface{}) { encode_ast_MapType(e, x.(*ast.MapType)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.MapType
			decode_ast_MapType(d, &x)
			return x
		})
}

func encode_ast_ParenExpr(e *codec.Encoder, x *ast.ParenExpr) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Lparen != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Lparen))
	}
	if x.X != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.X)
	}
	if x.Rparen != 0 {
		e.EncodeUint(2)
		e.EncodeInt(int64(x.Rparen))
	}
	e.EndStruct()
}

func decode_ast_ParenExpr(d *codec.Decoder, p **ast.ParenExpr) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ParenExpr)
		return
	}
	var x ast.ParenExpr
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Lparen = token.Pos(d.DecodeInt())
		case 1:
			x.X = d.DecodeAny().(ast.Expr)
		case 2:
			x.Rparen = token.Pos(d.DecodeInt())
		default:
			d.UnknownField("ast.ParenExpr", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ParenExpr{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ParenExpr(e, x.(*ast.ParenExpr)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ParenExpr
			decode_ast_ParenExpr(d, &x)
			return x
		})
}

func encode_ast_RangeStmt(e *codec.Encoder, x *ast.RangeStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.For != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.For))
	}
	if x.Key != nil {
		e.EncodeUint(1)
		e.EncodeAny(x.Key)
	}
	if x.Value != nil {
		e.EncodeUint(2)
		e.EncodeAny(x.Value)
	}
	if x.TokPos != 0 {
		e.EncodeUint(3)
		e.EncodeInt(int64(x.TokPos))
	}
	if x.Tok != 0 {
		e.EncodeUint(4)
		e.EncodeInt(int64(x.Tok))
	}
	if x.X != nil {
		e.EncodeUint(5)
		e.EncodeAny(x.X)
	}
	if x.Body != nil {
		e.EncodeUint(6)
		encode_ast_BlockStmt(e, x.Body)
	}
	e.EndStruct()
}

func decode_ast_RangeStmt(d *codec.Decoder, p **ast.RangeStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.RangeStmt)
		return
	}
	var x ast.RangeStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.For = token.Pos(d.DecodeInt())
		case 1:
			x.Key = d.DecodeAny().(ast.Expr)
		case 2:
			x.Value = d.DecodeAny().(ast.Expr)
		case 3:
			x.TokPos = token.Pos(d.DecodeInt())
		case 4:
			x.Tok = token.Token(d.DecodeInt())
		case 5:
			x.X = d.DecodeAny().(ast.Expr)
		case 6:
			decode_ast_BlockStmt(d, &x.Body)
		default:
			d.UnknownField("ast.RangeStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.RangeStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_RangeStmt(e, x.(*ast.RangeStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.RangeStmt
			decode_ast_RangeStmt(d, &x)
			return x
		})
}

func encode_ast_ReturnStmt(e *codec.Encoder, x *ast.ReturnStmt) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Return != 0 {
		e.EncodeUint(0)
		e.EncodeInt(int64(x.Return))
	}
	if x.Results != nil {
		e.EncodeUint(1)
		encode_slice_ast_Expr(e, x.Results)
	}
	e.EndStruct()
}

func decode_ast_ReturnStmt(d *codec.Decoder, p **ast.ReturnStmt) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.ReturnStmt)
		return
	}
	var x ast.ReturnStmt
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			x.Return = token.Pos(d.DecodeInt())
		case 1:
			decode_slice_ast_Expr(d, &x.Results)
		default:
			d.UnknownField("ast.ReturnStmt", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.ReturnStmt{},
		func(e *codec.Encoder, x interface{}) { encode_ast_ReturnStmt(e, x.(*ast.ReturnStmt)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.ReturnStmt
			decode_ast_ReturnStmt(d, &x)
			return x
		})
}

func encode_ast_Scope(e *codec.Encoder, x *ast.Scope) {
	if !e.StartStruct(x == nil, x) {
		return
	}
	if x.Outer != nil {
		e.EncodeUint(0)
		encode_ast_Scope(e, x.Outer)
	}
	if x.Objects != nil {
		e.EncodeUint(1)
		encode_map_string_ast_Object(e, x.Objects)
	}
	e.EndStruct()
}

func decode_ast_Scope(d *codec.Decoder, p **ast.Scope) {
	proceed, ref := d.StartStruct()
	if !proceed {
		return
	}
	if ref != nil {
		*p = ref.(*ast.Scope)
		return
	}
	var x ast.Scope
	d.StoreRef(&x)
	for {
		n := d.NextStructField()
		if n < 0 {
			break
		}
		switch n {
		case 0:
			decode_ast_Scope(d, &x.Outer)
		case 1:
			decode_map_string_ast_Object(d, &x.Objects)
		default:
			d.UnknownField("ast.Scope", n)
		}
		*p = &x
	}
}

func init() {
	codec.Register(&ast.Scope{},
		func(e *codec.Encoder, x interface{}) { encode_ast_Scope(e, x.(*ast.Scope)) },
		func(d *codec.Decoder) interface{} {
			var x *ast.Scope
			decode_ast_Scope(d, &x)
			return x
		})
}