Add dependencies/vendor (whatsapp)

1 files changed, 5232 insertions, 0 deletions

diff --git a/vendor/modernc.org/cc/v3/ast.go b/vendor/modernc.org/cc/v3/ast.go
new file mode 100644
index 00000000..7cd777a6
--- /dev/null
+++ b/vendor/modernc.org/cc/v3/ast.go
@@ -0,0 +1,5232 @@
+// Code generated by yy. DO NOT EDIT.
+
+// Copyright 2019 The CC Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cc
+
+import (
+	"fmt"
+
+	"modernc.org/token"
+)
+
+// AbstractDeclaratorCase represents case numbers of production AbstractDeclarator
+type AbstractDeclaratorCase int
+
+// Values of type AbstractDeclaratorCase
+const (
+	AbstractDeclaratorPtr AbstractDeclaratorCase = iota
+	AbstractDeclaratorDecl
+)
+
+// String implements fmt.Stringer
+func (n AbstractDeclaratorCase) String() string {
+	switch n {
+	case AbstractDeclaratorPtr:
+		return "AbstractDeclaratorPtr"
+	case AbstractDeclaratorDecl:
+		return "AbstractDeclaratorDecl"
+	default:
+		return fmt.Sprintf("AbstractDeclaratorCase(%v)", int(n))
+	}
+}
+
+// AbstractDeclarator represents data reduced by productions:
+//
+//	AbstractDeclarator:
+//	        Pointer                           // Case AbstractDeclaratorPtr
+//	|       Pointer DirectAbstractDeclarator  // Case AbstractDeclaratorDecl
+type AbstractDeclarator struct {
+	typ                      Type
+	Case                     AbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
+	DirectAbstractDeclarator *DirectAbstractDeclarator
+	Pointer                  *Pointer
+}
+
+// String implements fmt.Stringer.
+func (n *AbstractDeclarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AbstractDeclarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.Pointer.Position()
+	case 1:
+		if p := n.Pointer.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DirectAbstractDeclarator.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// AdditiveExpressionCase represents case numbers of production AdditiveExpression
+type AdditiveExpressionCase int
+
+// Values of type AdditiveExpressionCase
+const (
+	AdditiveExpressionMul AdditiveExpressionCase = iota
+	AdditiveExpressionAdd
+	AdditiveExpressionSub
+)
+
+// String implements fmt.Stringer
+func (n AdditiveExpressionCase) String() string {
+	switch n {
+	case AdditiveExpressionMul:
+		return "AdditiveExpressionMul"
+	case AdditiveExpressionAdd:
+		return "AdditiveExpressionAdd"
+	case AdditiveExpressionSub:
+		return "AdditiveExpressionSub"
+	default:
+		return fmt.Sprintf("AdditiveExpressionCase(%v)", int(n))
+	}
+}
+
+// AdditiveExpression represents data reduced by productions:
+//
+//	AdditiveExpression:
+//	        MultiplicativeExpression                         // Case AdditiveExpressionMul
+//	|       AdditiveExpression '+' MultiplicativeExpression  // Case AdditiveExpressionAdd
+//	|       AdditiveExpression '-' MultiplicativeExpression  // Case AdditiveExpressionSub
+type AdditiveExpression struct {
+	lexicalScope             Scope
+	Operand                  Operand
+	promote                  Type
+	IsSideEffectsFree        bool
+	AdditiveExpression       *AdditiveExpression
+	Case                     AdditiveExpressionCase `PrettyPrint:"stringer,zero"`
+	MultiplicativeExpression *MultiplicativeExpression
+	Token                    Token
+}
+
+// String implements fmt.Stringer.
+func (n *AdditiveExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AdditiveExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1, 2:
+		if p := n.AdditiveExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.MultiplicativeExpression.Position()
+	case 0:
+		return n.MultiplicativeExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// AlignmentSpecifierCase represents case numbers of production AlignmentSpecifier
+type AlignmentSpecifierCase int
+
+// Values of type AlignmentSpecifierCase
+const (
+	AlignmentSpecifierAlignasType AlignmentSpecifierCase = iota
+	AlignmentSpecifierAlignasExpr
+)
+
+// String implements fmt.Stringer
+func (n AlignmentSpecifierCase) String() string {
+	switch n {
+	case AlignmentSpecifierAlignasType:
+		return "AlignmentSpecifierAlignasType"
+	case AlignmentSpecifierAlignasExpr:
+		return "AlignmentSpecifierAlignasExpr"
+	default:
+		return fmt.Sprintf("AlignmentSpecifierCase(%v)", int(n))
+	}
+}
+
+// AlignmentSpecifier represents data reduced by productions:
+//
+//	AlignmentSpecifier:
+//	        "_Alignas" '(' TypeName ')'            // Case AlignmentSpecifierAlignasType
+//	|       "_Alignas" '(' ConstantExpression ')'  // Case AlignmentSpecifierAlignasExpr
+type AlignmentSpecifier struct {
+	Case               AlignmentSpecifierCase `PrettyPrint:"stringer,zero"`
+	ConstantExpression *ConstantExpression
+	Token              Token
+	Token2             Token
+	Token3             Token
+	TypeName           *TypeName
+}
+
+// String implements fmt.Stringer.
+func (n *AlignmentSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AlignmentSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// AndExpressionCase represents case numbers of production AndExpression
+type AndExpressionCase int
+
+// Values of type AndExpressionCase
+const (
+	AndExpressionEq AndExpressionCase = iota
+	AndExpressionAnd
+)
+
+// String implements fmt.Stringer
+func (n AndExpressionCase) String() string {
+	switch n {
+	case AndExpressionEq:
+		return "AndExpressionEq"
+	case AndExpressionAnd:
+		return "AndExpressionAnd"
+	default:
+		return fmt.Sprintf("AndExpressionCase(%v)", int(n))
+	}
+}
+
+// AndExpression represents data reduced by productions:
+//
+//	AndExpression:
+//	        EqualityExpression                    // Case AndExpressionEq
+//	|       AndExpression '&' EqualityExpression  // Case AndExpressionAnd
+type AndExpression struct {
+	Operand            Operand
+	promote            Type
+	IsSideEffectsFree  bool
+	AndExpression      *AndExpression
+	Case               AndExpressionCase `PrettyPrint:"stringer,zero"`
+	EqualityExpression *EqualityExpression
+	Token              Token
+}
+
+// String implements fmt.Stringer.
+func (n *AndExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AndExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.AndExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.EqualityExpression.Position()
+	case 0:
+		return n.EqualityExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ArgumentExpressionList represents data reduced by productions:
+//
+//	ArgumentExpressionList:
+//	        AssignmentExpression
+//	|       ArgumentExpressionList ',' AssignmentExpression
+type ArgumentExpressionList struct {
+	ArgumentExpressionList *ArgumentExpressionList
+	AssignmentExpression   *AssignmentExpression
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *ArgumentExpressionList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ArgumentExpressionList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.AssignmentExpression.Position()
+}
+
+// Asm represents data reduced by production:
+//
+//	Asm:
+//	        "__asm__" AsmQualifierList '(' STRINGLITERAL AsmArgList ')'
+type Asm struct {
+	AsmArgList       *AsmArgList
+	AsmQualifierList *AsmQualifierList
+	Token            Token
+	Token2           Token
+	Token3           Token
+	Token4           Token
+}
+
+// String implements fmt.Stringer.
+func (n *Asm) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Asm) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.AsmQualifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token2.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token3.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.AsmArgList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token4.Position()
+}
+
+// AsmArgList represents data reduced by productions:
+//
+//	AsmArgList:
+//	        ':' AsmExpressionList
+//	|       AsmArgList ':' AsmExpressionList
+type AsmArgList struct {
+	AsmArgList        *AsmArgList
+	AsmExpressionList *AsmExpressionList
+	Token             Token
+}
+
+// String implements fmt.Stringer.
+func (n *AsmArgList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmArgList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.AsmExpressionList.Position()
+}
+
+// AsmExpressionList represents data reduced by productions:
+//
+//	AsmExpressionList:
+//	        AsmIndex AssignmentExpression
+//	|       AsmExpressionList ',' AsmIndex AssignmentExpression
+type AsmExpressionList struct {
+	AsmExpressionList    *AsmExpressionList
+	AsmIndex             *AsmIndex
+	AssignmentExpression *AssignmentExpression
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *AsmExpressionList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmExpressionList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.AsmIndex.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.AssignmentExpression.Position()
+}
+
+// AsmFunctionDefinition represents data reduced by production:
+//
+//	AsmFunctionDefinition:
+//	        DeclarationSpecifiers Declarator AsmStatement
+type AsmFunctionDefinition struct {
+	AsmStatement          *AsmStatement
+	DeclarationSpecifiers *DeclarationSpecifiers
+	Declarator            *Declarator
+}
+
+// String implements fmt.Stringer.
+func (n *AsmFunctionDefinition) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmFunctionDefinition) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Declarator.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.AsmStatement.Position()
+}
+
+// AsmIndex represents data reduced by production:
+//
+//	AsmIndex:
+//	        '[' Expression ']'
+type AsmIndex struct {
+	Expression *Expression
+	Token      Token
+	Token2     Token
+}
+
+// String implements fmt.Stringer.
+func (n *AsmIndex) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmIndex) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Expression.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token2.Position()
+}
+
+// AsmQualifierCase represents case numbers of production AsmQualifier
+type AsmQualifierCase int
+
+// Values of type AsmQualifierCase
+const (
+	AsmQualifierVolatile AsmQualifierCase = iota
+	AsmQualifierInline
+	AsmQualifierGoto
+)
+
+// String implements fmt.Stringer
+func (n AsmQualifierCase) String() string {
+	switch n {
+	case AsmQualifierVolatile:
+		return "AsmQualifierVolatile"
+	case AsmQualifierInline:
+		return "AsmQualifierInline"
+	case AsmQualifierGoto:
+		return "AsmQualifierGoto"
+	default:
+		return fmt.Sprintf("AsmQualifierCase(%v)", int(n))
+	}
+}
+
+// AsmQualifier represents data reduced by productions:
+//
+//	AsmQualifier:
+//	        "volatile"  // Case AsmQualifierVolatile
+//	|       "inline"    // Case AsmQualifierInline
+//	|       "goto"      // Case AsmQualifierGoto
+type AsmQualifier struct {
+	Case  AsmQualifierCase `PrettyPrint:"stringer,zero"`
+	Token Token
+}
+
+// String implements fmt.Stringer.
+func (n *AsmQualifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmQualifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// AsmQualifierList represents data reduced by productions:
+//
+//	AsmQualifierList:
+//	        AsmQualifier
+//	|       AsmQualifierList AsmQualifier
+type AsmQualifierList struct {
+	AsmQualifier     *AsmQualifier
+	AsmQualifierList *AsmQualifierList
+}
+
+// String implements fmt.Stringer.
+func (n *AsmQualifierList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmQualifierList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.AsmQualifier.Position()
+}
+
+// AsmStatement represents data reduced by production:
+//
+//	AsmStatement:
+//	        Asm AttributeSpecifierList ';'
+type AsmStatement struct {
+	Asm                    *Asm
+	AttributeSpecifierList *AttributeSpecifierList
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *AsmStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AsmStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Asm.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token.Position()
+}
+
+// AssignmentExpressionCase represents case numbers of production AssignmentExpression
+type AssignmentExpressionCase int
+
+// Values of type AssignmentExpressionCase
+const (
+	AssignmentExpressionCond AssignmentExpressionCase = iota
+	AssignmentExpressionAssign
+	AssignmentExpressionMul
+	AssignmentExpressionDiv
+	AssignmentExpressionMod
+	AssignmentExpressionAdd
+	AssignmentExpressionSub
+	AssignmentExpressionLsh
+	AssignmentExpressionRsh
+	AssignmentExpressionAnd
+	AssignmentExpressionXor
+	AssignmentExpressionOr
+)
+
+// String implements fmt.Stringer
+func (n AssignmentExpressionCase) String() string {
+	switch n {
+	case AssignmentExpressionCond:
+		return "AssignmentExpressionCond"
+	case AssignmentExpressionAssign:
+		return "AssignmentExpressionAssign"
+	case AssignmentExpressionMul:
+		return "AssignmentExpressionMul"
+	case AssignmentExpressionDiv:
+		return "AssignmentExpressionDiv"
+	case AssignmentExpressionMod:
+		return "AssignmentExpressionMod"
+	case AssignmentExpressionAdd:
+		return "AssignmentExpressionAdd"
+	case AssignmentExpressionSub:
+		return "AssignmentExpressionSub"
+	case AssignmentExpressionLsh:
+		return "AssignmentExpressionLsh"
+	case AssignmentExpressionRsh:
+		return "AssignmentExpressionRsh"
+	case AssignmentExpressionAnd:
+		return "AssignmentExpressionAnd"
+	case AssignmentExpressionXor:
+		return "AssignmentExpressionXor"
+	case AssignmentExpressionOr:
+		return "AssignmentExpressionOr"
+	default:
+		return fmt.Sprintf("AssignmentExpressionCase(%v)", int(n))
+	}
+}
+
+// AssignmentExpression represents data reduced by productions:
+//
+//	AssignmentExpression:
+//	        ConditionalExpression                       // Case AssignmentExpressionCond
+//	|       UnaryExpression '=' AssignmentExpression    // Case AssignmentExpressionAssign
+//	|       UnaryExpression "*=" AssignmentExpression   // Case AssignmentExpressionMul
+//	|       UnaryExpression "/=" AssignmentExpression   // Case AssignmentExpressionDiv
+//	|       UnaryExpression "%=" AssignmentExpression   // Case AssignmentExpressionMod
+//	|       UnaryExpression "+=" AssignmentExpression   // Case AssignmentExpressionAdd
+//	|       UnaryExpression "-=" AssignmentExpression   // Case AssignmentExpressionSub
+//	|       UnaryExpression "<<=" AssignmentExpression  // Case AssignmentExpressionLsh
+//	|       UnaryExpression ">>=" AssignmentExpression  // Case AssignmentExpressionRsh
+//	|       UnaryExpression "&=" AssignmentExpression   // Case AssignmentExpressionAnd
+//	|       UnaryExpression "^=" AssignmentExpression   // Case AssignmentExpressionXor
+//	|       UnaryExpression "|=" AssignmentExpression   // Case AssignmentExpressionOr
+type AssignmentExpression struct {
+	Operand               Operand
+	InitializerOperand    Operand // When the expression is used in an initializer
+	lexicalScope          Scope
+	promote               Type
+	IsSideEffectsFree     bool
+	AssignmentExpression  *AssignmentExpression
+	Case                  AssignmentExpressionCase `PrettyPrint:"stringer,zero"`
+	ConditionalExpression *ConditionalExpression
+	Token                 Token
+	UnaryExpression       *UnaryExpression
+}
+
+// String implements fmt.Stringer.
+func (n *AssignmentExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AssignmentExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.ConditionalExpression.Position()
+	case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11:
+		if p := n.UnaryExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AssignmentExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// AtomicTypeSpecifier represents data reduced by production:
+//
+//	AtomicTypeSpecifier:
+//	        "_Atomic" '(' TypeName ')'
+type AtomicTypeSpecifier struct {
+	list     []*TypeSpecifier
+	Token    Token
+	Token2   Token
+	Token3   Token
+	TypeName *TypeName
+}
+
+// String implements fmt.Stringer.
+func (n *AtomicTypeSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AtomicTypeSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token2.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.TypeName.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token3.Position()
+}
+
+// AttributeSpecifier represents data reduced by production:
+//
+//	AttributeSpecifier:
+//	        "__attribute__" '(' '(' AttributeValueList ')' ')'
+type AttributeSpecifier struct {
+	AttributeValueList *AttributeValueList
+	Token              Token
+	Token2             Token
+	Token3             Token
+	Token4             Token
+	Token5             Token
+}
+
+// String implements fmt.Stringer.
+func (n *AttributeSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AttributeSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token2.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token3.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.AttributeValueList.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token4.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token5.Position()
+}
+
+// AttributeSpecifierList represents data reduced by productions:
+//
+//	AttributeSpecifierList:
+//	        AttributeSpecifier
+//	|       AttributeSpecifierList AttributeSpecifier
+type AttributeSpecifierList struct {
+	AttributeSpecifier     *AttributeSpecifier
+	AttributeSpecifierList *AttributeSpecifierList
+}
+
+// String implements fmt.Stringer.
+func (n *AttributeSpecifierList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AttributeSpecifierList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.AttributeSpecifier.Position()
+}
+
+// AttributeValueCase represents case numbers of production AttributeValue
+type AttributeValueCase int
+
+// Values of type AttributeValueCase
+const (
+	AttributeValueIdent AttributeValueCase = iota
+	AttributeValueExpr
+)
+
+// String implements fmt.Stringer
+func (n AttributeValueCase) String() string {
+	switch n {
+	case AttributeValueIdent:
+		return "AttributeValueIdent"
+	case AttributeValueExpr:
+		return "AttributeValueExpr"
+	default:
+		return fmt.Sprintf("AttributeValueCase(%v)", int(n))
+	}
+}
+
+// AttributeValue represents data reduced by productions:
+//
+//	AttributeValue:
+//	        IDENTIFIER                         // Case AttributeValueIdent
+//	|       IDENTIFIER '(' ExpressionList ')'  // Case AttributeValueExpr
+type AttributeValue struct {
+	lexicalScope   Scope
+	Case           AttributeValueCase `PrettyPrint:"stringer,zero"`
+	ExpressionList *ExpressionList
+	Token          Token
+	Token2         Token
+	Token3         Token
+}
+
+// String implements fmt.Stringer.
+func (n *AttributeValue) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AttributeValue) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.Token.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ExpressionList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// AttributeValueList represents data reduced by productions:
+//
+//	AttributeValueList:
+//	        AttributeValue
+//	|       AttributeValueList ',' AttributeValue
+type AttributeValueList struct {
+	AttributeValue     *AttributeValue
+	AttributeValueList *AttributeValueList
+	Token              Token
+}
+
+// String implements fmt.Stringer.
+func (n *AttributeValueList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *AttributeValueList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.AttributeValue.Position()
+}
+
+// BlockItemCase represents case numbers of production BlockItem
+type BlockItemCase int
+
+// Values of type BlockItemCase
+const (
+	BlockItemDecl BlockItemCase = iota
+	BlockItemStmt
+	BlockItemLabel
+	BlockItemFuncDef
+	BlockItemPragma
+)
+
+// String implements fmt.Stringer
+func (n BlockItemCase) String() string {
+	switch n {
+	case BlockItemDecl:
+		return "BlockItemDecl"
+	case BlockItemStmt:
+		return "BlockItemStmt"
+	case BlockItemLabel:
+		return "BlockItemLabel"
+	case BlockItemFuncDef:
+		return "BlockItemFuncDef"
+	case BlockItemPragma:
+		return "BlockItemPragma"
+	default:
+		return fmt.Sprintf("BlockItemCase(%v)", int(n))
+	}
+}
+
+// BlockItem represents data reduced by productions:
+//
+//	BlockItem:
+//	        Declaration                                         // Case BlockItemDecl
+//	|       Statement                                           // Case BlockItemStmt
+//	|       LabelDeclaration                                    // Case BlockItemLabel
+//	|       DeclarationSpecifiers Declarator CompoundStatement  // Case BlockItemFuncDef
+//	|       PragmaSTDC                                          // Case BlockItemPragma
+type BlockItem struct {
+	fn                    *FunctionDefinition   // Case FuncDef
+	closure               map[StringID]struct{} // Case FuncDef
+	Last                  bool
+	Case                  BlockItemCase `PrettyPrint:"stringer,zero"`
+	CompoundStatement     *CompoundStatement
+	Declaration           *Declaration
+	DeclarationSpecifiers *DeclarationSpecifiers
+	Declarator            *Declarator
+	LabelDeclaration      *LabelDeclaration
+	PragmaSTDC            *PragmaSTDC
+	Statement             *Statement
+}
+
+// String implements fmt.Stringer.
+func (n *BlockItem) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *BlockItem) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.Declaration.Position()
+	case 3:
+		if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.CompoundStatement.Position()
+	case 2:
+		return n.LabelDeclaration.Position()
+	case 4:
+		return n.PragmaSTDC.Position()
+	case 1:
+		return n.Statement.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// BlockItemList represents data reduced by productions:
+//
+//	BlockItemList:
+//	        BlockItem
+//	|       BlockItemList BlockItem
+type BlockItemList struct {
+	BlockItem     *BlockItem
+	BlockItemList *BlockItemList
+}
+
+// String implements fmt.Stringer.
+func (n *BlockItemList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *BlockItemList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.BlockItem.Position()
+}
+
+// CastExpressionCase represents case numbers of production CastExpression
+type CastExpressionCase int
+
+// Values of type CastExpressionCase
+const (
+	CastExpressionUnary CastExpressionCase = iota
+	CastExpressionCast
+)
+
+// String implements fmt.Stringer
+func (n CastExpressionCase) String() string {
+	switch n {
+	case CastExpressionUnary:
+		return "CastExpressionUnary"
+	case CastExpressionCast:
+		return "CastExpressionCast"
+	default:
+		return fmt.Sprintf("CastExpressionCase(%v)", int(n))
+	}
+}
+
+// CastExpression represents data reduced by productions:
+//
+//	CastExpression:
+//	        UnaryExpression                  // Case CastExpressionUnary
+//	|       '(' TypeName ')' CastExpression  // Case CastExpressionCast
+type CastExpression struct {
+	Operand           Operand
+	IsSideEffectsFree bool
+	Case              CastExpressionCase `PrettyPrint:"stringer,zero"`
+	CastExpression    *CastExpression
+	Token             Token
+	Token2            Token
+	TypeName          *TypeName
+	UnaryExpression   *UnaryExpression
+}
+
+// String implements fmt.Stringer.
+func (n *CastExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *CastExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.CastExpression.Position()
+	case 0:
+		return n.UnaryExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// CompoundStatement represents data reduced by production:
+//
+//	CompoundStatement:
+//	        '{' BlockItemList '}'
+type CompoundStatement struct {
+	Operand       Operand
+	children      []*CompoundStatement
+	declarations  []*Declaration
+	isJumpTarget  bool
+	labeledStmts  []*LabeledStatement
+	parent        *CompoundStatement
+	scope         Scope
+	BlockItemList *BlockItemList
+	Token         Token
+	Token2        Token
+}
+
+// String implements fmt.Stringer.
+func (n *CompoundStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *CompoundStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.BlockItemList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token2.Position()
+}
+
+// ConditionalExpressionCase represents case numbers of production ConditionalExpression
+type ConditionalExpressionCase int
+
+// Values of type ConditionalExpressionCase
+const (
+	ConditionalExpressionLOr ConditionalExpressionCase = iota
+	ConditionalExpressionCond
+)
+
+// String implements fmt.Stringer
+func (n ConditionalExpressionCase) String() string {
+	switch n {
+	case ConditionalExpressionLOr:
+		return "ConditionalExpressionLOr"
+	case ConditionalExpressionCond:
+		return "ConditionalExpressionCond"
+	default:
+		return fmt.Sprintf("ConditionalExpressionCase(%v)", int(n))
+	}
+}
+
+// ConditionalExpression represents data reduced by productions:
+//
+//	ConditionalExpression:
+//	        LogicalOrExpression                                           // Case ConditionalExpressionLOr
+//	|       LogicalOrExpression '?' Expression ':' ConditionalExpression  // Case ConditionalExpressionCond
+type ConditionalExpression struct {
+	Operand               Operand
+	IsSideEffectsFree     bool
+	Case                  ConditionalExpressionCase `PrettyPrint:"stringer,zero"`
+	ConditionalExpression *ConditionalExpression
+	Expression            *Expression
+	LogicalOrExpression   *LogicalOrExpression
+	Token                 Token
+	Token2                Token
+}
+
+// String implements fmt.Stringer.
+func (n *ConditionalExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ConditionalExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.LogicalOrExpression.Position()
+	case 1:
+		if p := n.LogicalOrExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.ConditionalExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ConstantExpression represents data reduced by production:
+//
+//	ConstantExpression:
+//	        ConditionalExpression
+type ConstantExpression struct {
+	Operand               Operand
+	ConditionalExpression *ConditionalExpression
+}
+
+// String implements fmt.Stringer.
+func (n *ConstantExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ConstantExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.ConditionalExpression.Position()
+}
+
+// Declaration represents data reduced by production:
+//
+//	Declaration:
+//	        DeclarationSpecifiers InitDeclaratorList ';'
+type Declaration struct {
+	DeclarationSpecifiers *DeclarationSpecifiers
+	InitDeclaratorList    *InitDeclaratorList
+	Token                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *Declaration) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Declaration) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.InitDeclaratorList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token.Position()
+}
+
+// DeclarationList represents data reduced by productions:
+//
+//	DeclarationList:
+//	        Declaration
+//	|       DeclarationList Declaration
+type DeclarationList struct {
+	Declaration     *Declaration
+	DeclarationList *DeclarationList
+}
+
+// String implements fmt.Stringer.
+func (n *DeclarationList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *DeclarationList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Declaration.Position()
+}
+
+// DeclarationSpecifiersCase represents case numbers of production DeclarationSpecifiers
+type DeclarationSpecifiersCase int
+
+// Values of type DeclarationSpecifiersCase
+const (
+	DeclarationSpecifiersStorage DeclarationSpecifiersCase = iota
+	DeclarationSpecifiersTypeSpec
+	DeclarationSpecifiersTypeQual
+	DeclarationSpecifiersFunc
+	DeclarationSpecifiersAlignSpec
+	DeclarationSpecifiersAttribute
+)
+
+// String implements fmt.Stringer
+func (n DeclarationSpecifiersCase) String() string {
+	switch n {
+	case DeclarationSpecifiersStorage:
+		return "DeclarationSpecifiersStorage"
+	case DeclarationSpecifiersTypeSpec:
+		return "DeclarationSpecifiersTypeSpec"
+	case DeclarationSpecifiersTypeQual:
+		return "DeclarationSpecifiersTypeQual"
+	case DeclarationSpecifiersFunc:
+		return "DeclarationSpecifiersFunc"
+	case DeclarationSpecifiersAlignSpec:
+		return "DeclarationSpecifiersAlignSpec"
+	case DeclarationSpecifiersAttribute:
+		return "DeclarationSpecifiersAttribute"
+	default:
+		return fmt.Sprintf("DeclarationSpecifiersCase(%v)", int(n))
+	}
+}
+
+// DeclarationSpecifiers represents data reduced by productions:
+//
+//	DeclarationSpecifiers:
+//	        StorageClassSpecifier DeclarationSpecifiers  // Case DeclarationSpecifiersStorage
+//	|       TypeSpecifier DeclarationSpecifiers          // Case DeclarationSpecifiersTypeSpec
+//	|       TypeQualifier DeclarationSpecifiers          // Case DeclarationSpecifiersTypeQual
+//	|       FunctionSpecifier DeclarationSpecifiers      // Case DeclarationSpecifiersFunc
+//	|       AlignmentSpecifier DeclarationSpecifiers     // Case DeclarationSpecifiersAlignSpec
+//	|       AttributeSpecifier DeclarationSpecifiers     // Case DeclarationSpecifiersAttribute
+type DeclarationSpecifiers struct {
+	class                 storageClass
+	AlignmentSpecifier    *AlignmentSpecifier
+	AttributeSpecifier    *AttributeSpecifier
+	Case                  DeclarationSpecifiersCase `PrettyPrint:"stringer,zero"`
+	DeclarationSpecifiers *DeclarationSpecifiers
+	FunctionSpecifier     *FunctionSpecifier
+	StorageClassSpecifier *StorageClassSpecifier
+	TypeQualifier         *TypeQualifier
+	TypeSpecifier         *TypeSpecifier
+}
+
+// String implements fmt.Stringer.
+func (n *DeclarationSpecifiers) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *DeclarationSpecifiers) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 4:
+		if p := n.AlignmentSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	case 5:
+		if p := n.AttributeSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	case 3:
+		if p := n.FunctionSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	case 0:
+		if p := n.StorageClassSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	case 2:
+		if p := n.TypeQualifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	case 1:
+		if p := n.TypeSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.DeclarationSpecifiers.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// Declarator represents data reduced by production:
+//
+//	Declarator:
+//	        Pointer DirectDeclarator AttributeSpecifierList
+type Declarator struct {
+	Linkage                Linkage
+	Read                   int
+	StorageClass           StorageClass
+	Write                  int
+	funcDefinition         *FunctionDefinition
+	lhs                    map[*Declarator]struct{}
+	td                     typeDescriptor
+	typ                    Type
+	AddressTaken           bool
+	IsParameter            bool
+	IsTypedefName          bool
+	SubjectOfAsgnOp        bool
+	SubjectOfIncDec        bool
+	called                 bool
+	fnDef                  bool
+	hasInitializer         bool
+	implicit               bool
+	AttributeSpecifierList *AttributeSpecifierList
+	DirectDeclarator       *DirectDeclarator
+	Pointer                *Pointer
+}
+
+// String implements fmt.Stringer.
+func (n *Declarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Declarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Pointer.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.DirectDeclarator.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.AttributeSpecifierList.Position()
+}
+
+// Designation represents data reduced by production:
+//
+//	Designation:
+//	        DesignatorList '='
+type Designation struct {
+	DesignatorList *DesignatorList
+	Token          Token
+}
+
+// String implements fmt.Stringer.
+func (n *Designation) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Designation) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.DesignatorList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token.Position()
+}
+
+// DesignatorCase represents case numbers of production Designator
+type DesignatorCase int
+
+// Values of type DesignatorCase
+const (
+	DesignatorIndex DesignatorCase = iota
+	DesignatorField
+	DesignatorField2
+)
+
+// String implements fmt.Stringer
+func (n DesignatorCase) String() string {
+	switch n {
+	case DesignatorIndex:
+		return "DesignatorIndex"
+	case DesignatorField:
+		return "DesignatorField"
+	case DesignatorField2:
+		return "DesignatorField2"
+	default:
+		return fmt.Sprintf("DesignatorCase(%v)", int(n))
+	}
+}
+
+// Designator represents data reduced by productions:
+//
+//	Designator:
+//	        '[' ConstantExpression ']'  // Case DesignatorIndex
+//	|       '.' IDENTIFIER              // Case DesignatorField
+//	|       IDENTIFIER ':'              // Case DesignatorField2
+type Designator struct {
+	lexicalScope       Scope
+	Case               DesignatorCase `PrettyPrint:"stringer,zero"`
+	ConstantExpression *ConstantExpression
+	Token              Token
+	Token2             Token
+}
+
+// String implements fmt.Stringer.
+func (n *Designator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Designator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 1, 2:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// DesignatorList represents data reduced by productions:
+//
+//	DesignatorList:
+//	        Designator
+//	|       DesignatorList Designator
+type DesignatorList struct {
+	Designator     *Designator
+	DesignatorList *DesignatorList
+}
+
+// String implements fmt.Stringer.
+func (n *DesignatorList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *DesignatorList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Designator.Position()
+}
+
+// DirectAbstractDeclaratorCase represents case numbers of production DirectAbstractDeclarator
+type DirectAbstractDeclaratorCase int
+
+// Values of type DirectAbstractDeclaratorCase
+const (
+	DirectAbstractDeclaratorDecl DirectAbstractDeclaratorCase = iota
+	DirectAbstractDeclaratorArr
+	DirectAbstractDeclaratorStaticArr
+	DirectAbstractDeclaratorArrStatic
+	DirectAbstractDeclaratorArrStar
+	DirectAbstractDeclaratorFunc
+)
+
+// String implements fmt.Stringer
+func (n DirectAbstractDeclaratorCase) String() string {
+	switch n {
+	case DirectAbstractDeclaratorDecl:
+		return "DirectAbstractDeclaratorDecl"
+	case DirectAbstractDeclaratorArr:
+		return "DirectAbstractDeclaratorArr"
+	case DirectAbstractDeclaratorStaticArr:
+		return "DirectAbstractDeclaratorStaticArr"
+	case DirectAbstractDeclaratorArrStatic:
+		return "DirectAbstractDeclaratorArrStatic"
+	case DirectAbstractDeclaratorArrStar:
+		return "DirectAbstractDeclaratorArrStar"
+	case DirectAbstractDeclaratorFunc:
+		return "DirectAbstractDeclaratorFunc"
+	default:
+		return fmt.Sprintf("DirectAbstractDeclaratorCase(%v)", int(n))
+	}
+}
+
+// DirectAbstractDeclarator represents data reduced by productions:
+//
+//	DirectAbstractDeclarator:
+//	        '(' AbstractDeclarator ')'                                                     // Case DirectAbstractDeclaratorDecl
+//	|       DirectAbstractDeclarator '[' TypeQualifiers AssignmentExpression ']'           // Case DirectAbstractDeclaratorArr
+//	|       DirectAbstractDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'  // Case DirectAbstractDeclaratorStaticArr
+//	|       DirectAbstractDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'  // Case DirectAbstractDeclaratorArrStatic
+//	|       DirectAbstractDeclarator '[' '*' ']'                                           // Case DirectAbstractDeclaratorArrStar
+//	|       DirectAbstractDeclarator '(' ParameterTypeList ')'                             // Case DirectAbstractDeclaratorFunc
+type DirectAbstractDeclarator struct {
+	paramScope               Scope
+	typeQualifiers           *typeBase
+	AbstractDeclarator       *AbstractDeclarator
+	AssignmentExpression     *AssignmentExpression
+	Case                     DirectAbstractDeclaratorCase `PrettyPrint:"stringer,zero"`
+	DirectAbstractDeclarator *DirectAbstractDeclarator
+	ParameterTypeList        *ParameterTypeList
+	Token                    Token
+	Token2                   Token
+	Token3                   Token
+	TypeQualifiers           *TypeQualifiers
+}
+
+// String implements fmt.Stringer.
+func (n *DirectAbstractDeclarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *DirectAbstractDeclarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 5:
+		if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ParameterTypeList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 4:
+		if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 2:
+		if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 1:
+		if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 3:
+		if p := n.DirectAbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AbstractDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// DirectDeclaratorCase represents case numbers of production DirectDeclarator
+type DirectDeclaratorCase int
+
+// Values of type DirectDeclaratorCase
+const (
+	DirectDeclaratorIdent DirectDeclaratorCase = iota
+	DirectDeclaratorDecl
+	DirectDeclaratorArr
+	DirectDeclaratorStaticArr
+	DirectDeclaratorArrStatic
+	DirectDeclaratorStar
+	DirectDeclaratorFuncParam
+	DirectDeclaratorFuncIdent
+)
+
+// String implements fmt.Stringer
+func (n DirectDeclaratorCase) String() string {
+	switch n {
+	case DirectDeclaratorIdent:
+		return "DirectDeclaratorIdent"
+	case DirectDeclaratorDecl:
+		return "DirectDeclaratorDecl"
+	case DirectDeclaratorArr:
+		return "DirectDeclaratorArr"
+	case DirectDeclaratorStaticArr:
+		return "DirectDeclaratorStaticArr"
+	case DirectDeclaratorArrStatic:
+		return "DirectDeclaratorArrStatic"
+	case DirectDeclaratorStar:
+		return "DirectDeclaratorStar"
+	case DirectDeclaratorFuncParam:
+		return "DirectDeclaratorFuncParam"
+	case DirectDeclaratorFuncIdent:
+		return "DirectDeclaratorFuncIdent"
+	default:
+		return fmt.Sprintf("DirectDeclaratorCase(%v)", int(n))
+	}
+}
+
+// DirectDeclarator represents data reduced by productions:
+//
+//	DirectDeclarator:
+//	        IDENTIFIER Asm                                                         // Case DirectDeclaratorIdent
+//	|       '(' AttributeSpecifierList Declarator ')'                              // Case DirectDeclaratorDecl
+//	|       DirectDeclarator '[' TypeQualifiers AssignmentExpression ']'           // Case DirectDeclaratorArr
+//	|       DirectDeclarator '[' "static" TypeQualifiers AssignmentExpression ']'  // Case DirectDeclaratorStaticArr
+//	|       DirectDeclarator '[' TypeQualifiers "static" AssignmentExpression ']'  // Case DirectDeclaratorArrStatic
+//	|       DirectDeclarator '[' TypeQualifiers '*' ']'                            // Case DirectDeclaratorStar
+//	|       DirectDeclarator '(' ParameterTypeList ')'                             // Case DirectDeclaratorFuncParam
+//	|       DirectDeclarator '(' IdentifierList ')'                                // Case DirectDeclaratorFuncIdent
+type DirectDeclarator struct {
+	lexicalScope           Scope
+	paramScope             Scope
+	typeQualifiers         *typeBase
+	idListNoDeclList       bool
+	Asm                    *Asm
+	AssignmentExpression   *AssignmentExpression
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   DirectDeclaratorCase `PrettyPrint:"stringer,zero"`
+	Declarator             *Declarator
+	DirectDeclarator       *DirectDeclarator
+	IdentifierList         *IdentifierList
+	ParameterTypeList      *ParameterTypeList
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+	TypeQualifiers         *TypeQualifiers
+}
+
+// String implements fmt.Stringer.
+func (n *DirectDeclarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *DirectDeclarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 7:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.IdentifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 6:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ParameterTypeList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 3:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 2:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 4:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 5:
+		if p := n.DirectDeclarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Asm.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// EnumSpecifierCase represents case numbers of production EnumSpecifier
+type EnumSpecifierCase int
+
+// Values of type EnumSpecifierCase
+const (
+	EnumSpecifierDef EnumSpecifierCase = iota
+	EnumSpecifierTag
+)
+
+// String implements fmt.Stringer
+func (n EnumSpecifierCase) String() string {
+	switch n {
+	case EnumSpecifierDef:
+		return "EnumSpecifierDef"
+	case EnumSpecifierTag:
+		return "EnumSpecifierTag"
+	default:
+		return fmt.Sprintf("EnumSpecifierCase(%v)", int(n))
+	}
+}
+
+// EnumSpecifier represents data reduced by productions:
+//
+//	EnumSpecifier:
+//	        "enum" AttributeSpecifierList IDENTIFIER '{' EnumeratorList ',' '}'  // Case EnumSpecifierDef
+//	|       "enum" AttributeSpecifierList IDENTIFIER                             // Case EnumSpecifierTag
+type EnumSpecifier struct {
+	lexicalScope           Scope
+	typ                    Type
+	min                    Value
+	max                    Value
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   EnumSpecifierCase `PrettyPrint:"stringer,zero"`
+	EnumeratorList         *EnumeratorList
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+	Token4                 Token
+	Token5                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *EnumSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *EnumSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.EnumeratorList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token5.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// EnumeratorCase represents case numbers of production Enumerator
+type EnumeratorCase int
+
+// Values of type EnumeratorCase
+const (
+	EnumeratorIdent EnumeratorCase = iota
+	EnumeratorExpr
+)
+
+// String implements fmt.Stringer
+func (n EnumeratorCase) String() string {
+	switch n {
+	case EnumeratorIdent:
+		return "EnumeratorIdent"
+	case EnumeratorExpr:
+		return "EnumeratorExpr"
+	default:
+		return fmt.Sprintf("EnumeratorCase(%v)", int(n))
+	}
+}
+
+// Enumerator represents data reduced by productions:
+//
+//	Enumerator:
+//	        IDENTIFIER AttributeSpecifierList                         // Case EnumeratorIdent
+//	|       IDENTIFIER AttributeSpecifierList '=' ConstantExpression  // Case EnumeratorExpr
+type Enumerator struct {
+	lexicalScope           Scope
+	Operand                Operand
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   EnumeratorCase `PrettyPrint:"stringer,zero"`
+	ConstantExpression     *ConstantExpression
+	Token                  Token
+	Token2                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *Enumerator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Enumerator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AttributeSpecifierList.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.ConstantExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// EnumeratorList represents data reduced by productions:
+//
+//	EnumeratorList:
+//	        Enumerator
+//	|       EnumeratorList ',' Enumerator
+type EnumeratorList struct {
+	Enumerator     *Enumerator
+	EnumeratorList *EnumeratorList
+	Token          Token
+}
+
+// String implements fmt.Stringer.
+func (n *EnumeratorList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *EnumeratorList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Enumerator.Position()
+}
+
+// EqualityExpressionCase represents case numbers of production EqualityExpression
+type EqualityExpressionCase int
+
+// Values of type EqualityExpressionCase
+const (
+	EqualityExpressionRel EqualityExpressionCase = iota
+	EqualityExpressionEq
+	EqualityExpressionNeq
+)
+
+// String implements fmt.Stringer
+func (n EqualityExpressionCase) String() string {
+	switch n {
+	case EqualityExpressionRel:
+		return "EqualityExpressionRel"
+	case EqualityExpressionEq:
+		return "EqualityExpressionEq"
+	case EqualityExpressionNeq:
+		return "EqualityExpressionNeq"
+	default:
+		return fmt.Sprintf("EqualityExpressionCase(%v)", int(n))
+	}
+}
+
+// EqualityExpression represents data reduced by productions:
+//
+//	EqualityExpression:
+//	        RelationalExpression                          // Case EqualityExpressionRel
+//	|       EqualityExpression "==" RelationalExpression  // Case EqualityExpressionEq
+//	|       EqualityExpression "!=" RelationalExpression  // Case EqualityExpressionNeq
+type EqualityExpression struct {
+	Operand              Operand
+	promote              Type
+	IsSideEffectsFree    bool
+	Case                 EqualityExpressionCase `PrettyPrint:"stringer,zero"`
+	EqualityExpression   *EqualityExpression
+	RelationalExpression *RelationalExpression
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *EqualityExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *EqualityExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1, 2:
+		if p := n.EqualityExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.RelationalExpression.Position()
+	case 0:
+		return n.RelationalExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ExclusiveOrExpressionCase represents case numbers of production ExclusiveOrExpression
+type ExclusiveOrExpressionCase int
+
+// Values of type ExclusiveOrExpressionCase
+const (
+	ExclusiveOrExpressionAnd ExclusiveOrExpressionCase = iota
+	ExclusiveOrExpressionXor
+)
+
+// String implements fmt.Stringer
+func (n ExclusiveOrExpressionCase) String() string {
+	switch n {
+	case ExclusiveOrExpressionAnd:
+		return "ExclusiveOrExpressionAnd"
+	case ExclusiveOrExpressionXor:
+		return "ExclusiveOrExpressionXor"
+	default:
+		return fmt.Sprintf("ExclusiveOrExpressionCase(%v)", int(n))
+	}
+}
+
+// ExclusiveOrExpression represents data reduced by productions:
+//
+//	ExclusiveOrExpression:
+//	        AndExpression                            // Case ExclusiveOrExpressionAnd
+//	|       ExclusiveOrExpression '^' AndExpression  // Case ExclusiveOrExpressionXor
+type ExclusiveOrExpression struct {
+	Operand               Operand
+	promote               Type
+	IsSideEffectsFree     bool
+	AndExpression         *AndExpression
+	Case                  ExclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
+	ExclusiveOrExpression *ExclusiveOrExpression
+	Token                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *ExclusiveOrExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ExclusiveOrExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.AndExpression.Position()
+	case 1:
+		if p := n.ExclusiveOrExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AndExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ExpressionCase represents case numbers of production Expression
+type ExpressionCase int
+
+// Values of type ExpressionCase
+const (
+	ExpressionAssign ExpressionCase = iota
+	ExpressionComma
+)
+
+// String implements fmt.Stringer
+func (n ExpressionCase) String() string {
+	switch n {
+	case ExpressionAssign:
+		return "ExpressionAssign"
+	case ExpressionComma:
+		return "ExpressionComma"
+	default:
+		return fmt.Sprintf("ExpressionCase(%v)", int(n))
+	}
+}
+
+// Expression represents data reduced by productions:
+//
+//	Expression:
+//	        AssignmentExpression                 // Case ExpressionAssign
+//	|       Expression ',' AssignmentExpression  // Case ExpressionComma
+type Expression struct {
+	Operand              Operand
+	IsSideEffectsFree    bool
+	AssignmentExpression *AssignmentExpression
+	Case                 ExpressionCase `PrettyPrint:"stringer,zero"`
+	Expression           *Expression
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *Expression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Expression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.AssignmentExpression.Position()
+	case 1:
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AssignmentExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ExpressionList represents data reduced by productions:
+//
+//	ExpressionList:
+//	        AssignmentExpression
+//	|       ExpressionList ',' AssignmentExpression
+type ExpressionList struct {
+	AssignmentExpression *AssignmentExpression
+	ExpressionList       *ExpressionList
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *ExpressionList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ExpressionList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.AssignmentExpression.Position()
+}
+
+// ExpressionStatement represents data reduced by production:
+//
+//	ExpressionStatement:
+//	        Expression AttributeSpecifierList ';'
+type ExpressionStatement struct {
+	AttributeSpecifierList *AttributeSpecifierList
+	Expression             *Expression
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *ExpressionStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ExpressionStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Expression.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token.Position()
+}
+
+// ExternalDeclarationCase represents case numbers of production ExternalDeclaration
+type ExternalDeclarationCase int
+
+// Values of type ExternalDeclarationCase
+const (
+	ExternalDeclarationFuncDef ExternalDeclarationCase = iota
+	ExternalDeclarationDecl
+	ExternalDeclarationAsm
+	ExternalDeclarationAsmStmt
+	ExternalDeclarationEmpty
+	ExternalDeclarationPragma
+)
+
+// String implements fmt.Stringer
+func (n ExternalDeclarationCase) String() string {
+	switch n {
+	case ExternalDeclarationFuncDef:
+		return "ExternalDeclarationFuncDef"
+	case ExternalDeclarationDecl:
+		return "ExternalDeclarationDecl"
+	case ExternalDeclarationAsm:
+		return "ExternalDeclarationAsm"
+	case ExternalDeclarationAsmStmt:
+		return "ExternalDeclarationAsmStmt"
+	case ExternalDeclarationEmpty:
+		return "ExternalDeclarationEmpty"
+	case ExternalDeclarationPragma:
+		return "ExternalDeclarationPragma"
+	default:
+		return fmt.Sprintf("ExternalDeclarationCase(%v)", int(n))
+	}
+}
+
+// ExternalDeclaration represents data reduced by productions:
+//
+//	ExternalDeclaration:
+//	        FunctionDefinition     // Case ExternalDeclarationFuncDef
+//	|       Declaration            // Case ExternalDeclarationDecl
+//	|       AsmFunctionDefinition  // Case ExternalDeclarationAsm
+//	|       AsmStatement           // Case ExternalDeclarationAsmStmt
+//	|       ';'                    // Case ExternalDeclarationEmpty
+//	|       PragmaSTDC             // Case ExternalDeclarationPragma
+type ExternalDeclaration struct {
+	AsmFunctionDefinition *AsmFunctionDefinition
+	AsmStatement          *AsmStatement
+	Case                  ExternalDeclarationCase `PrettyPrint:"stringer,zero"`
+	Declaration           *Declaration
+	FunctionDefinition    *FunctionDefinition
+	PragmaSTDC            *PragmaSTDC
+	Token                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *ExternalDeclaration) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ExternalDeclaration) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 2:
+		return n.AsmFunctionDefinition.Position()
+	case 3:
+		return n.AsmStatement.Position()
+	case 1:
+		return n.Declaration.Position()
+	case 0:
+		return n.FunctionDefinition.Position()
+	case 5:
+		return n.PragmaSTDC.Position()
+	case 4:
+		return n.Token.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// FunctionDefinition represents data reduced by production:
+//
+//	FunctionDefinition:
+//	        DeclarationSpecifiers Declarator DeclarationList CompoundStatement
+type FunctionDefinition struct {
+	CallSiteComplexExpr   []*AssignmentExpression
+	CompositeLiterals     []*PostfixExpression
+	ComputedGotos         map[StringID]*UnaryExpression
+	Gotos                 map[StringID]*JumpStatement
+	InitDeclarators       []*InitDeclarator
+	Labels                map[StringID]*LabeledStatement
+	ReturnComplexExpr     []*Expression
+	VLAs                  []*Declarator
+	compoundStatements    []*CompoundStatement
+	checked               bool
+	CompoundStatement     *CompoundStatement
+	DeclarationList       *DeclarationList
+	DeclarationSpecifiers *DeclarationSpecifiers
+	Declarator            *Declarator
+}
+
+// String implements fmt.Stringer.
+func (n *FunctionDefinition) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *FunctionDefinition) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Declarator.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.DeclarationList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.CompoundStatement.Position()
+}
+
+// FunctionSpecifierCase represents case numbers of production FunctionSpecifier
+type FunctionSpecifierCase int
+
+// Values of type FunctionSpecifierCase
+const (
+	FunctionSpecifierInline FunctionSpecifierCase = iota
+	FunctionSpecifierNoreturn
+)
+
+// String implements fmt.Stringer
+func (n FunctionSpecifierCase) String() string {
+	switch n {
+	case FunctionSpecifierInline:
+		return "FunctionSpecifierInline"
+	case FunctionSpecifierNoreturn:
+		return "FunctionSpecifierNoreturn"
+	default:
+		return fmt.Sprintf("FunctionSpecifierCase(%v)", int(n))
+	}
+}
+
+// FunctionSpecifier represents data reduced by productions:
+//
+//	FunctionSpecifier:
+//	        "inline"     // Case FunctionSpecifierInline
+//	|       "_Noreturn"  // Case FunctionSpecifierNoreturn
+type FunctionSpecifier struct {
+	Case  FunctionSpecifierCase `PrettyPrint:"stringer,zero"`
+	Token Token
+}
+
+// String implements fmt.Stringer.
+func (n *FunctionSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *FunctionSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// IdentifierList represents data reduced by productions:
+//
+//	IdentifierList:
+//	        IDENTIFIER
+//	|       IdentifierList ',' IDENTIFIER
+type IdentifierList struct {
+	lexicalScope   Scope
+	IdentifierList *IdentifierList
+	Token          Token
+	Token2         Token
+}
+
+// String implements fmt.Stringer.
+func (n *IdentifierList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *IdentifierList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// InclusiveOrExpressionCase represents case numbers of production InclusiveOrExpression
+type InclusiveOrExpressionCase int
+
+// Values of type InclusiveOrExpressionCase
+const (
+	InclusiveOrExpressionXor InclusiveOrExpressionCase = iota
+	InclusiveOrExpressionOr
+)
+
+// String implements fmt.Stringer
+func (n InclusiveOrExpressionCase) String() string {
+	switch n {
+	case InclusiveOrExpressionXor:
+		return "InclusiveOrExpressionXor"
+	case InclusiveOrExpressionOr:
+		return "InclusiveOrExpressionOr"
+	default:
+		return fmt.Sprintf("InclusiveOrExpressionCase(%v)", int(n))
+	}
+}
+
+// InclusiveOrExpression represents data reduced by productions:
+//
+//	InclusiveOrExpression:
+//	        ExclusiveOrExpression                            // Case InclusiveOrExpressionXor
+//	|       InclusiveOrExpression '|' ExclusiveOrExpression  // Case InclusiveOrExpressionOr
+type InclusiveOrExpression struct {
+	Operand               Operand
+	promote               Type
+	IsSideEffectsFree     bool
+	Case                  InclusiveOrExpressionCase `PrettyPrint:"stringer,zero"`
+	ExclusiveOrExpression *ExclusiveOrExpression
+	InclusiveOrExpression *InclusiveOrExpression
+	Token                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *InclusiveOrExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *InclusiveOrExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.ExclusiveOrExpression.Position()
+	case 1:
+		if p := n.InclusiveOrExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.ExclusiveOrExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// InitDeclaratorCase represents case numbers of production InitDeclarator
+type InitDeclaratorCase int
+
+// Values of type InitDeclaratorCase
+const (
+	InitDeclaratorDecl InitDeclaratorCase = iota
+	InitDeclaratorInit
+)
+
+// String implements fmt.Stringer
+func (n InitDeclaratorCase) String() string {
+	switch n {
+	case InitDeclaratorDecl:
+		return "InitDeclaratorDecl"
+	case InitDeclaratorInit:
+		return "InitDeclaratorInit"
+	default:
+		return fmt.Sprintf("InitDeclaratorCase(%v)", int(n))
+	}
+}
+
+// InitDeclarator represents data reduced by productions:
+//
+//	InitDeclarator:
+//	        Declarator AttributeSpecifierList                  // Case InitDeclaratorDecl
+//	|       Declarator AttributeSpecifierList '=' Initializer  // Case InitDeclaratorInit
+type InitDeclarator struct {
+	initializer            *InitializerValue
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   InitDeclaratorCase `PrettyPrint:"stringer,zero"`
+	Declarator             *Declarator
+	Initializer            *Initializer
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *InitDeclarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *InitDeclarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AttributeSpecifierList.Position()
+	case 1:
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Initializer.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// InitDeclaratorList represents data reduced by productions:
+//
+//	InitDeclaratorList:
+//	        InitDeclarator
+//	|       InitDeclaratorList ',' AttributeSpecifierList InitDeclarator
+type InitDeclaratorList struct {
+	AttributeSpecifierList *AttributeSpecifierList
+	InitDeclarator         *InitDeclarator
+	InitDeclaratorList     *InitDeclaratorList
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *InitDeclaratorList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *InitDeclaratorList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.InitDeclarator.Position()
+}
+
+// InitializerCase represents case numbers of production Initializer
+type InitializerCase int
+
+// Values of type InitializerCase
+const (
+	InitializerExpr InitializerCase = iota
+	InitializerInitList
+)
+
+// String implements fmt.Stringer
+func (n InitializerCase) String() string {
+	switch n {
+	case InitializerExpr:
+		return "InitializerExpr"
+	case InitializerInitList:
+		return "InitializerInitList"
+	default:
+		return fmt.Sprintf("InitializerCase(%v)", int(n))
+	}
+}
+
+// Initializer represents data reduced by productions:
+//
+//	Initializer:
+//	        AssignmentExpression         // Case InitializerExpr
+//	|       '{' InitializerList ',' '}'  // Case InitializerInitList
+type Initializer struct {
+	Field                Field   // Where aplicable
+	Offset               uintptr // Case Expr
+	field0               Field
+	list                 []*Initializer
+	parent               *Initializer
+	trailingComma        *Token
+	typ                  Type
+	isConst              bool
+	isZero               bool
+	AssignmentExpression *AssignmentExpression
+	Case                 InitializerCase `PrettyPrint:"stringer,zero"`
+	InitializerList      *InitializerList
+	Token                Token
+	Token2               Token
+	Token3               Token
+}
+
+// String implements fmt.Stringer.
+func (n *Initializer) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Initializer) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.AssignmentExpression.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.InitializerList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// InitializerList represents data reduced by productions:
+//
+//	InitializerList:
+//	        Designation Initializer
+//	|       InitializerList ',' Designation Initializer
+type InitializerList struct {
+	list            []*Initializer
+	isConst         bool
+	isZero          bool
+	Designation     *Designation
+	Initializer     *Initializer
+	InitializerList *InitializerList
+	Token           Token
+}
+
+// String implements fmt.Stringer.
+func (n *InitializerList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *InitializerList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Designation.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Initializer.Position()
+}
+
+// IterationStatementCase represents case numbers of production IterationStatement
+type IterationStatementCase int
+
+// Values of type IterationStatementCase
+const (
+	IterationStatementWhile IterationStatementCase = iota
+	IterationStatementDo
+	IterationStatementFor
+	IterationStatementForDecl
+)
+
+// String implements fmt.Stringer
+func (n IterationStatementCase) String() string {
+	switch n {
+	case IterationStatementWhile:
+		return "IterationStatementWhile"
+	case IterationStatementDo:
+		return "IterationStatementDo"
+	case IterationStatementFor:
+		return "IterationStatementFor"
+	case IterationStatementForDecl:
+		return "IterationStatementForDecl"
+	default:
+		return fmt.Sprintf("IterationStatementCase(%v)", int(n))
+	}
+}
+
+// IterationStatement represents data reduced by productions:
+//
+//	IterationStatement:
+//	        "while" '(' Expression ')' Statement                              // Case IterationStatementWhile
+//	|       "do" Statement "while" '(' Expression ')' ';'                     // Case IterationStatementDo
+//	|       "for" '(' Expression ';' Expression ';' Expression ')' Statement  // Case IterationStatementFor
+//	|       "for" '(' Declaration Expression ';' Expression ')' Statement     // Case IterationStatementForDecl
+type IterationStatement struct {
+	Case        IterationStatementCase `PrettyPrint:"stringer,zero"`
+	Declaration *Declaration
+	Expression  *Expression
+	Expression2 *Expression
+	Expression3 *Expression
+	Statement   *Statement
+	Token       Token
+	Token2      Token
+	Token3      Token
+	Token4      Token
+	Token5      Token
+}
+
+// String implements fmt.Stringer.
+func (n *IterationStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *IterationStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Statement.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token5.Position()
+	case 3:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Declaration.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 2:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token5.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// JumpStatementCase represents case numbers of production JumpStatement
+type JumpStatementCase int
+
+// Values of type JumpStatementCase
+const (
+	JumpStatementGoto JumpStatementCase = iota
+	JumpStatementGotoExpr
+	JumpStatementContinue
+	JumpStatementBreak
+	JumpStatementReturn
+)
+
+// String implements fmt.Stringer
+func (n JumpStatementCase) String() string {
+	switch n {
+	case JumpStatementGoto:
+		return "JumpStatementGoto"
+	case JumpStatementGotoExpr:
+		return "JumpStatementGotoExpr"
+	case JumpStatementContinue:
+		return "JumpStatementContinue"
+	case JumpStatementBreak:
+		return "JumpStatementBreak"
+	case JumpStatementReturn:
+		return "JumpStatementReturn"
+	default:
+		return fmt.Sprintf("JumpStatementCase(%v)", int(n))
+	}
+}
+
+// JumpStatement represents data reduced by productions:
+//
+//	JumpStatement:
+//	        "goto" IDENTIFIER ';'      // Case JumpStatementGoto
+//	|       "goto" '*' Expression ';'  // Case JumpStatementGotoExpr
+//	|       "continue" ';'             // Case JumpStatementContinue
+//	|       "break" ';'                // Case JumpStatementBreak
+//	|       "return" Expression ';'    // Case JumpStatementReturn
+type JumpStatement struct {
+	context      Node
+	lexicalScope Scope
+	Case         JumpStatementCase `PrettyPrint:"stringer,zero"`
+	Expression   *Expression
+	Token        Token
+	Token2       Token
+	Token3       Token
+}
+
+// String implements fmt.Stringer.
+func (n *JumpStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *JumpStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 4:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 2, 3:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// LabelDeclaration represents data reduced by production:
+//
+//	LabelDeclaration:
+//	        "__label__" IdentifierList ';'
+type LabelDeclaration struct {
+	IdentifierList *IdentifierList
+	Token          Token
+	Token2         Token
+}
+
+// String implements fmt.Stringer.
+func (n *LabelDeclaration) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *LabelDeclaration) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.IdentifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token2.Position()
+}
+
+// LabeledStatementCase represents case numbers of production LabeledStatement
+type LabeledStatementCase int
+
+// Values of type LabeledStatementCase
+const (
+	LabeledStatementLabel LabeledStatementCase = iota
+	LabeledStatementCaseLabel
+	LabeledStatementRange
+	LabeledStatementDefault
+)
+
+// String implements fmt.Stringer
+func (n LabeledStatementCase) String() string {
+	switch n {
+	case LabeledStatementLabel:
+		return "LabeledStatementLabel"
+	case LabeledStatementCaseLabel:
+		return "LabeledStatementCaseLabel"
+	case LabeledStatementRange:
+		return "LabeledStatementRange"
+	case LabeledStatementDefault:
+		return "LabeledStatementDefault"
+	default:
+		return fmt.Sprintf("LabeledStatementCase(%v)", int(n))
+	}
+}
+
+// LabeledStatement represents data reduced by productions:
+//
+//	LabeledStatement:
+//	        IDENTIFIER ':' AttributeSpecifierList Statement                   // Case LabeledStatementLabel
+//	|       "case" ConstantExpression ':' Statement                           // Case LabeledStatementCaseLabel
+//	|       "case" ConstantExpression "..." ConstantExpression ':' Statement  // Case LabeledStatementRange
+//	|       "default" ':' Statement                                           // Case LabeledStatementDefault
+type LabeledStatement struct {
+	block                  *CompoundStatement
+	lexicalScope           Scope
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   LabeledStatementCase `PrettyPrint:"stringer,zero"`
+	ConstantExpression     *ConstantExpression
+	ConstantExpression2    *ConstantExpression
+	Statement              *Statement
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *LabeledStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *LabeledStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 2:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 0:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 3:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// LogicalAndExpressionCase represents case numbers of production LogicalAndExpression
+type LogicalAndExpressionCase int
+
+// Values of type LogicalAndExpressionCase
+const (
+	LogicalAndExpressionOr LogicalAndExpressionCase = iota
+	LogicalAndExpressionLAnd
+)
+
+// String implements fmt.Stringer
+func (n LogicalAndExpressionCase) String() string {
+	switch n {
+	case LogicalAndExpressionOr:
+		return "LogicalAndExpressionOr"
+	case LogicalAndExpressionLAnd:
+		return "LogicalAndExpressionLAnd"
+	default:
+		return fmt.Sprintf("LogicalAndExpressionCase(%v)", int(n))
+	}
+}
+
+// LogicalAndExpression represents data reduced by productions:
+//
+//	LogicalAndExpression:
+//	        InclusiveOrExpression                            // Case LogicalAndExpressionOr
+//	|       LogicalAndExpression "&&" InclusiveOrExpression  // Case LogicalAndExpressionLAnd
+type LogicalAndExpression struct {
+	Operand               Operand
+	IsSideEffectsFree     bool
+	Case                  LogicalAndExpressionCase `PrettyPrint:"stringer,zero"`
+	InclusiveOrExpression *InclusiveOrExpression
+	LogicalAndExpression  *LogicalAndExpression
+	Token                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *LogicalAndExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *LogicalAndExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.InclusiveOrExpression.Position()
+	case 1:
+		if p := n.LogicalAndExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.InclusiveOrExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// LogicalOrExpressionCase represents case numbers of production LogicalOrExpression
+type LogicalOrExpressionCase int
+
+// Values of type LogicalOrExpressionCase
+const (
+	LogicalOrExpressionLAnd LogicalOrExpressionCase = iota
+	LogicalOrExpressionLOr
+)
+
+// String implements fmt.Stringer
+func (n LogicalOrExpressionCase) String() string {
+	switch n {
+	case LogicalOrExpressionLAnd:
+		return "LogicalOrExpressionLAnd"
+	case LogicalOrExpressionLOr:
+		return "LogicalOrExpressionLOr"
+	default:
+		return fmt.Sprintf("LogicalOrExpressionCase(%v)", int(n))
+	}
+}
+
+// LogicalOrExpression represents data reduced by productions:
+//
+//	LogicalOrExpression:
+//	        LogicalAndExpression                           // Case LogicalOrExpressionLAnd
+//	|       LogicalOrExpression "||" LogicalAndExpression  // Case LogicalOrExpressionLOr
+type LogicalOrExpression struct {
+	Operand              Operand
+	IsSideEffectsFree    bool
+	Case                 LogicalOrExpressionCase `PrettyPrint:"stringer,zero"`
+	LogicalAndExpression *LogicalAndExpression
+	LogicalOrExpression  *LogicalOrExpression
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *LogicalOrExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *LogicalOrExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.LogicalAndExpression.Position()
+	case 1:
+		if p := n.LogicalOrExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.LogicalAndExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// MultiplicativeExpressionCase represents case numbers of production MultiplicativeExpression
+type MultiplicativeExpressionCase int
+
+// Values of type MultiplicativeExpressionCase
+const (
+	MultiplicativeExpressionCast MultiplicativeExpressionCase = iota
+	MultiplicativeExpressionMul
+	MultiplicativeExpressionDiv
+	MultiplicativeExpressionMod
+)
+
+// String implements fmt.Stringer
+func (n MultiplicativeExpressionCase) String() string {
+	switch n {
+	case MultiplicativeExpressionCast:
+		return "MultiplicativeExpressionCast"
+	case MultiplicativeExpressionMul:
+		return "MultiplicativeExpressionMul"
+	case MultiplicativeExpressionDiv:
+		return "MultiplicativeExpressionDiv"
+	case MultiplicativeExpressionMod:
+		return "MultiplicativeExpressionMod"
+	default:
+		return fmt.Sprintf("MultiplicativeExpressionCase(%v)", int(n))
+	}
+}
+
+// MultiplicativeExpression represents data reduced by productions:
+//
+//	MultiplicativeExpression:
+//	        CastExpression                               // Case MultiplicativeExpressionCast
+//	|       MultiplicativeExpression '*' CastExpression  // Case MultiplicativeExpressionMul
+//	|       MultiplicativeExpression '/' CastExpression  // Case MultiplicativeExpressionDiv
+//	|       MultiplicativeExpression '%' CastExpression  // Case MultiplicativeExpressionMod
+type MultiplicativeExpression struct {
+	Operand                  Operand
+	promote                  Type
+	IsSideEffectsFree        bool
+	Case                     MultiplicativeExpressionCase `PrettyPrint:"stringer,zero"`
+	CastExpression           *CastExpression
+	MultiplicativeExpression *MultiplicativeExpression
+	Token                    Token
+}
+
+// String implements fmt.Stringer.
+func (n *MultiplicativeExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *MultiplicativeExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.CastExpression.Position()
+	case 1, 2, 3:
+		if p := n.MultiplicativeExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.CastExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ParameterDeclarationCase represents case numbers of production ParameterDeclaration
+type ParameterDeclarationCase int
+
+// Values of type ParameterDeclarationCase
+const (
+	ParameterDeclarationDecl ParameterDeclarationCase = iota
+	ParameterDeclarationAbstract
+)
+
+// String implements fmt.Stringer
+func (n ParameterDeclarationCase) String() string {
+	switch n {
+	case ParameterDeclarationDecl:
+		return "ParameterDeclarationDecl"
+	case ParameterDeclarationAbstract:
+		return "ParameterDeclarationAbstract"
+	default:
+		return fmt.Sprintf("ParameterDeclarationCase(%v)", int(n))
+	}
+}
+
+// ParameterDeclaration represents data reduced by productions:
+//
+//	ParameterDeclaration:
+//	        DeclarationSpecifiers Declarator AttributeSpecifierList  // Case ParameterDeclarationDecl
+//	|       DeclarationSpecifiers AbstractDeclarator                 // Case ParameterDeclarationAbstract
+type ParameterDeclaration struct {
+	typ                    Type
+	AbstractDeclarator     *AbstractDeclarator
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   ParameterDeclarationCase `PrettyPrint:"stringer,zero"`
+	DeclarationSpecifiers  *DeclarationSpecifiers
+	Declarator             *Declarator
+}
+
+// String implements fmt.Stringer.
+func (n *ParameterDeclaration) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ParameterDeclaration) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AbstractDeclarator.Position()
+	case 0:
+		if p := n.DeclarationSpecifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AttributeSpecifierList.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ParameterList represents data reduced by productions:
+//
+//	ParameterList:
+//	        ParameterDeclaration
+//	|       ParameterList ',' ParameterDeclaration
+type ParameterList struct {
+	ParameterDeclaration *ParameterDeclaration
+	ParameterList        *ParameterList
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *ParameterList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ParameterList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.ParameterDeclaration.Position()
+}
+
+// ParameterTypeListCase represents case numbers of production ParameterTypeList
+type ParameterTypeListCase int
+
+// Values of type ParameterTypeListCase
+const (
+	ParameterTypeListList ParameterTypeListCase = iota
+	ParameterTypeListVar
+)
+
+// String implements fmt.Stringer
+func (n ParameterTypeListCase) String() string {
+	switch n {
+	case ParameterTypeListList:
+		return "ParameterTypeListList"
+	case ParameterTypeListVar:
+		return "ParameterTypeListVar"
+	default:
+		return fmt.Sprintf("ParameterTypeListCase(%v)", int(n))
+	}
+}
+
+// ParameterTypeList represents data reduced by productions:
+//
+//	ParameterTypeList:
+//	        ParameterList            // Case ParameterTypeListList
+//	|       ParameterList ',' "..."  // Case ParameterTypeListVar
+type ParameterTypeList struct {
+	Case          ParameterTypeListCase `PrettyPrint:"stringer,zero"`
+	ParameterList *ParameterList
+	Token         Token
+	Token2        Token
+}
+
+// String implements fmt.Stringer.
+func (n *ParameterTypeList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ParameterTypeList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.ParameterList.Position()
+	case 1:
+		if p := n.ParameterList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// PointerCase represents case numbers of production Pointer
+type PointerCase int
+
+// Values of type PointerCase
+const (
+	PointerTypeQual PointerCase = iota
+	PointerPtr
+	PointerBlock
+)
+
+// String implements fmt.Stringer
+func (n PointerCase) String() string {
+	switch n {
+	case PointerTypeQual:
+		return "PointerTypeQual"
+	case PointerPtr:
+		return "PointerPtr"
+	case PointerBlock:
+		return "PointerBlock"
+	default:
+		return fmt.Sprintf("PointerCase(%v)", int(n))
+	}
+}
+
+// Pointer represents data reduced by productions:
+//
+//	Pointer:
+//	        '*' TypeQualifiers          // Case PointerTypeQual
+//	|       '*' TypeQualifiers Pointer  // Case PointerPtr
+//	|       '^' TypeQualifiers          // Case PointerBlock
+type Pointer struct {
+	typeQualifiers *typeBase
+	Case           PointerCase `PrettyPrint:"stringer,zero"`
+	Pointer        *Pointer
+	Token          Token
+	TypeQualifiers *TypeQualifiers
+}
+
+// String implements fmt.Stringer.
+func (n *Pointer) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Pointer) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0, 2:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.TypeQualifiers.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Pointer.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// PostfixExpressionCase represents case numbers of production PostfixExpression
+type PostfixExpressionCase int
+
+// Values of type PostfixExpressionCase
+const (
+	PostfixExpressionPrimary PostfixExpressionCase = iota
+	PostfixExpressionIndex
+	PostfixExpressionCall
+	PostfixExpressionSelect
+	PostfixExpressionPSelect
+	PostfixExpressionInc
+	PostfixExpressionDec
+	PostfixExpressionComplit
+	PostfixExpressionTypeCmp
+	PostfixExpressionChooseExpr
+)
+
+// String implements fmt.Stringer
+func (n PostfixExpressionCase) String() string {
+	switch n {
+	case PostfixExpressionPrimary:
+		return "PostfixExpressionPrimary"
+	case PostfixExpressionIndex:
+		return "PostfixExpressionIndex"
+	case PostfixExpressionCall:
+		return "PostfixExpressionCall"
+	case PostfixExpressionSelect:
+		return "PostfixExpressionSelect"
+	case PostfixExpressionPSelect:
+		return "PostfixExpressionPSelect"
+	case PostfixExpressionInc:
+		return "PostfixExpressionInc"
+	case PostfixExpressionDec:
+		return "PostfixExpressionDec"
+	case PostfixExpressionComplit:
+		return "PostfixExpressionComplit"
+	case PostfixExpressionTypeCmp:
+		return "PostfixExpressionTypeCmp"
+	case PostfixExpressionChooseExpr:
+		return "PostfixExpressionChooseExpr"
+	default:
+		return fmt.Sprintf("PostfixExpressionCase(%v)", int(n))
+	}
+}
+
+// PostfixExpression represents data reduced by productions:
+//
+//	PostfixExpression:
+//	        PrimaryExpression                                                                                       // Case PostfixExpressionPrimary
+//	|       PostfixExpression '[' Expression ']'                                                                    // Case PostfixExpressionIndex
+//	|       PostfixExpression '(' ArgumentExpressionList ')'                                                        // Case PostfixExpressionCall
+//	|       PostfixExpression '.' IDENTIFIER                                                                        // Case PostfixExpressionSelect
+//	|       PostfixExpression "->" IDENTIFIER                                                                       // Case PostfixExpressionPSelect
+//	|       PostfixExpression "++"                                                                                  // Case PostfixExpressionInc
+//	|       PostfixExpression "--"                                                                                  // Case PostfixExpressionDec
+//	|       '(' TypeName ')' '{' InitializerList ',' '}'                                                            // Case PostfixExpressionComplit
+//	|       "__builtin_types_compatible_p" '(' TypeName ',' TypeName ')'                                            // Case PostfixExpressionTypeCmp
+//	|       "__builtin_choose_expr" '(' AssignmentExpression ',' AssignmentExpression ',' AssignmentExpression ')'  // Case PostfixExpressionChooseExpr
+type PostfixExpression struct {
+	Operand                Operand
+	Field                  Field // Case Select, PSelect
+	IsSideEffectsFree      bool
+	ArgumentExpressionList *ArgumentExpressionList
+	AssignmentExpression   *AssignmentExpression
+	AssignmentExpression2  *AssignmentExpression
+	AssignmentExpression3  *AssignmentExpression
+	Case                   PostfixExpressionCase `PrettyPrint:"stringer,zero"`
+	Expression             *Expression
+	InitializerList        *InitializerList
+	PostfixExpression      *PostfixExpression
+	PrimaryExpression      *PrimaryExpression
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+	Token4                 Token
+	Token5                 Token
+	TypeName               *TypeName
+	TypeName2              *TypeName
+}
+
+// String implements fmt.Stringer.
+func (n *PostfixExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *PostfixExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 5, 6:
+		if p := n.PostfixExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token.Position()
+	case 2:
+		if p := n.PostfixExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ArgumentExpressionList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 1:
+		if p := n.PostfixExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 3, 4:
+		if p := n.PostfixExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 0:
+		return n.PrimaryExpression.Position()
+	case 9:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AssignmentExpression3.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token5.Position()
+	case 8:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName2.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token4.Position()
+	case 7:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.InitializerList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token5.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// PragmaSTDC represents data reduced by production:
+//
+//	PragmaSTDC:
+//	        "__pragma_stdc" IDENTIFIER IDENTIFIER IDENTIFIER
+type PragmaSTDC struct {
+	Token  Token
+	Token2 Token
+	Token3 Token
+	Token4 Token
+}
+
+// String implements fmt.Stringer.
+func (n *PragmaSTDC) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *PragmaSTDC) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.Token.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token2.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.Token3.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token4.Position()
+}
+
+// PrimaryExpressionCase represents case numbers of production PrimaryExpression
+type PrimaryExpressionCase int
+
+// Values of type PrimaryExpressionCase
+const (
+	PrimaryExpressionIdent PrimaryExpressionCase = iota
+	PrimaryExpressionInt
+	PrimaryExpressionFloat
+	PrimaryExpressionEnum
+	PrimaryExpressionChar
+	PrimaryExpressionLChar
+	PrimaryExpressionString
+	PrimaryExpressionLString
+	PrimaryExpressionExpr
+	PrimaryExpressionStmt
+)
+
+// String implements fmt.Stringer
+func (n PrimaryExpressionCase) String() string {
+	switch n {
+	case PrimaryExpressionIdent:
+		return "PrimaryExpressionIdent"
+	case PrimaryExpressionInt:
+		return "PrimaryExpressionInt"
+	case PrimaryExpressionFloat:
+		return "PrimaryExpressionFloat"
+	case PrimaryExpressionEnum:
+		return "PrimaryExpressionEnum"
+	case PrimaryExpressionChar:
+		return "PrimaryExpressionChar"
+	case PrimaryExpressionLChar:
+		return "PrimaryExpressionLChar"
+	case PrimaryExpressionString:
+		return "PrimaryExpressionString"
+	case PrimaryExpressionLString:
+		return "PrimaryExpressionLString"
+	case PrimaryExpressionExpr:
+		return "PrimaryExpressionExpr"
+	case PrimaryExpressionStmt:
+		return "PrimaryExpressionStmt"
+	default:
+		return fmt.Sprintf("PrimaryExpressionCase(%v)", int(n))
+	}
+}
+
+// PrimaryExpression represents data reduced by productions:
+//
+//	PrimaryExpression:
+//	        IDENTIFIER                 // Case PrimaryExpressionIdent
+//	|       INTCONST                   // Case PrimaryExpressionInt
+//	|       FLOATCONST                 // Case PrimaryExpressionFloat
+//	|       ENUMCONST                  // Case PrimaryExpressionEnum
+//	|       CHARCONST                  // Case PrimaryExpressionChar
+//	|       LONGCHARCONST              // Case PrimaryExpressionLChar
+//	|       STRINGLITERAL              // Case PrimaryExpressionString
+//	|       LONGSTRINGLITERAL          // Case PrimaryExpressionLString
+//	|       '(' Expression ')'         // Case PrimaryExpressionExpr
+//	|       '(' CompoundStatement ')'  // Case PrimaryExpressionStmt
+type PrimaryExpression struct {
+	Operand           Operand
+	lexicalScope      Scope
+	resolvedIn        Scope
+	resolvedTo        Node
+	IsSideEffectsFree bool
+	Case              PrimaryExpressionCase `PrettyPrint:"stringer,zero"`
+	CompoundStatement *CompoundStatement
+	Expression        *Expression
+	Token             Token
+	Token2            Token
+}
+
+// String implements fmt.Stringer.
+func (n *PrimaryExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *PrimaryExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0, 1, 2, 3, 4, 5, 6, 7:
+		return n.Token.Position()
+	case 9:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.CompoundStatement.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 8:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// RelationalExpressionCase represents case numbers of production RelationalExpression
+type RelationalExpressionCase int
+
+// Values of type RelationalExpressionCase
+const (
+	RelationalExpressionShift RelationalExpressionCase = iota
+	RelationalExpressionLt
+	RelationalExpressionGt
+	RelationalExpressionLeq
+	RelationalExpressionGeq
+)
+
+// String implements fmt.Stringer
+func (n RelationalExpressionCase) String() string {
+	switch n {
+	case RelationalExpressionShift:
+		return "RelationalExpressionShift"
+	case RelationalExpressionLt:
+		return "RelationalExpressionLt"
+	case RelationalExpressionGt:
+		return "RelationalExpressionGt"
+	case RelationalExpressionLeq:
+		return "RelationalExpressionLeq"
+	case RelationalExpressionGeq:
+		return "RelationalExpressionGeq"
+	default:
+		return fmt.Sprintf("RelationalExpressionCase(%v)", int(n))
+	}
+}
+
+// RelationalExpression represents data reduced by productions:
+//
+//	RelationalExpression:
+//	        ShiftExpression                            // Case RelationalExpressionShift
+//	|       RelationalExpression '<' ShiftExpression   // Case RelationalExpressionLt
+//	|       RelationalExpression '>' ShiftExpression   // Case RelationalExpressionGt
+//	|       RelationalExpression "<=" ShiftExpression  // Case RelationalExpressionLeq
+//	|       RelationalExpression ">=" ShiftExpression  // Case RelationalExpressionGeq
+type RelationalExpression struct {
+	Operand              Operand
+	promote              Type
+	IsSideEffectsFree    bool
+	Case                 RelationalExpressionCase `PrettyPrint:"stringer,zero"`
+	RelationalExpression *RelationalExpression
+	ShiftExpression      *ShiftExpression
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *RelationalExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *RelationalExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1, 2, 3, 4:
+		if p := n.RelationalExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.ShiftExpression.Position()
+	case 0:
+		return n.ShiftExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// SelectionStatementCase represents case numbers of production SelectionStatement
+type SelectionStatementCase int
+
+// Values of type SelectionStatementCase
+const (
+	SelectionStatementIf SelectionStatementCase = iota
+	SelectionStatementIfElse
+	SelectionStatementSwitch
+)
+
+// String implements fmt.Stringer
+func (n SelectionStatementCase) String() string {
+	switch n {
+	case SelectionStatementIf:
+		return "SelectionStatementIf"
+	case SelectionStatementIfElse:
+		return "SelectionStatementIfElse"
+	case SelectionStatementSwitch:
+		return "SelectionStatementSwitch"
+	default:
+		return fmt.Sprintf("SelectionStatementCase(%v)", int(n))
+	}
+}
+
+// SelectionStatement represents data reduced by productions:
+//
+//	SelectionStatement:
+//	        "if" '(' Expression ')' Statement                   // Case SelectionStatementIf
+//	|       "if" '(' Expression ')' Statement "else" Statement  // Case SelectionStatementIfElse
+//	|       "switch" '(' Expression ')' Statement               // Case SelectionStatementSwitch
+type SelectionStatement struct {
+	promote    Type // switch expression promoted type
+	cases      []*LabeledStatement
+	Case       SelectionStatementCase `PrettyPrint:"stringer,zero"`
+	Expression *Expression
+	Statement  *Statement
+	Statement2 *Statement
+	Token      Token
+	Token2     Token
+	Token3     Token
+	Token4     Token
+}
+
+// String implements fmt.Stringer.
+func (n *SelectionStatement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *SelectionStatement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0, 2:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement.Position()
+	case 1:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token3.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Statement.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token4.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Statement2.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// ShiftExpressionCase represents case numbers of production ShiftExpression
+type ShiftExpressionCase int
+
+// Values of type ShiftExpressionCase
+const (
+	ShiftExpressionAdd ShiftExpressionCase = iota
+	ShiftExpressionLsh
+	ShiftExpressionRsh
+)
+
+// String implements fmt.Stringer
+func (n ShiftExpressionCase) String() string {
+	switch n {
+	case ShiftExpressionAdd:
+		return "ShiftExpressionAdd"
+	case ShiftExpressionLsh:
+		return "ShiftExpressionLsh"
+	case ShiftExpressionRsh:
+		return "ShiftExpressionRsh"
+	default:
+		return fmt.Sprintf("ShiftExpressionCase(%v)", int(n))
+	}
+}
+
+// ShiftExpression represents data reduced by productions:
+//
+//	ShiftExpression:
+//	        AdditiveExpression                       // Case ShiftExpressionAdd
+//	|       ShiftExpression "<<" AdditiveExpression  // Case ShiftExpressionLsh
+//	|       ShiftExpression ">>" AdditiveExpression  // Case ShiftExpressionRsh
+type ShiftExpression struct {
+	Operand            Operand
+	promote            Type // shift count promoted type
+	IsSideEffectsFree  bool
+	AdditiveExpression *AdditiveExpression
+	Case               ShiftExpressionCase `PrettyPrint:"stringer,zero"`
+	ShiftExpression    *ShiftExpression
+	Token              Token
+}
+
+// String implements fmt.Stringer.
+func (n *ShiftExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *ShiftExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.AdditiveExpression.Position()
+	case 1, 2:
+		if p := n.ShiftExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AdditiveExpression.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// SpecifierQualifierListCase represents case numbers of production SpecifierQualifierList
+type SpecifierQualifierListCase int
+
+// Values of type SpecifierQualifierListCase
+const (
+	SpecifierQualifierListTypeSpec SpecifierQualifierListCase = iota
+	SpecifierQualifierListTypeQual
+	SpecifierQualifierListAlignSpec
+	SpecifierQualifierListAttribute
+)
+
+// String implements fmt.Stringer
+func (n SpecifierQualifierListCase) String() string {
+	switch n {
+	case SpecifierQualifierListTypeSpec:
+		return "SpecifierQualifierListTypeSpec"
+	case SpecifierQualifierListTypeQual:
+		return "SpecifierQualifierListTypeQual"
+	case SpecifierQualifierListAlignSpec:
+		return "SpecifierQualifierListAlignSpec"
+	case SpecifierQualifierListAttribute:
+		return "SpecifierQualifierListAttribute"
+	default:
+		return fmt.Sprintf("SpecifierQualifierListCase(%v)", int(n))
+	}
+}
+
+// SpecifierQualifierList represents data reduced by productions:
+//
+//	SpecifierQualifierList:
+//	        TypeSpecifier SpecifierQualifierList       // Case SpecifierQualifierListTypeSpec
+//	|       TypeQualifier SpecifierQualifierList       // Case SpecifierQualifierListTypeQual
+//	|       AlignmentSpecifier SpecifierQualifierList  // Case SpecifierQualifierListAlignSpec
+//	|       AttributeSpecifier SpecifierQualifierList  // Case SpecifierQualifierListAttribute
+type SpecifierQualifierList struct {
+	noStorageClass
+	AlignmentSpecifier     *AlignmentSpecifier
+	AttributeSpecifier     *AttributeSpecifier
+	Case                   SpecifierQualifierListCase `PrettyPrint:"stringer,zero"`
+	SpecifierQualifierList *SpecifierQualifierList
+	TypeQualifier          *TypeQualifier
+	TypeSpecifier          *TypeSpecifier
+}
+
+// String implements fmt.Stringer.
+func (n *SpecifierQualifierList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *SpecifierQualifierList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 2:
+		if p := n.AlignmentSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.SpecifierQualifierList.Position()
+	case 3:
+		if p := n.AttributeSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.SpecifierQualifierList.Position()
+	case 1:
+		if p := n.TypeQualifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.SpecifierQualifierList.Position()
+	case 0:
+		if p := n.TypeSpecifier.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.SpecifierQualifierList.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// StatementCase represents case numbers of production Statement
+type StatementCase int
+
+// Values of type StatementCase
+const (
+	StatementLabeled StatementCase = iota
+	StatementCompound
+	StatementExpr
+	StatementSelection
+	StatementIteration
+	StatementJump
+	StatementAsm
+)
+
+// String implements fmt.Stringer
+func (n StatementCase) String() string {
+	switch n {
+	case StatementLabeled:
+		return "StatementLabeled"
+	case StatementCompound:
+		return "StatementCompound"
+	case StatementExpr:
+		return "StatementExpr"
+	case StatementSelection:
+		return "StatementSelection"
+	case StatementIteration:
+		return "StatementIteration"
+	case StatementJump:
+		return "StatementJump"
+	case StatementAsm:
+		return "StatementAsm"
+	default:
+		return fmt.Sprintf("StatementCase(%v)", int(n))
+	}
+}
+
+// Statement represents data reduced by productions:
+//
+//	Statement:
+//	        LabeledStatement     // Case StatementLabeled
+//	|       CompoundStatement    // Case StatementCompound
+//	|       ExpressionStatement  // Case StatementExpr
+//	|       SelectionStatement   // Case StatementSelection
+//	|       IterationStatement   // Case StatementIteration
+//	|       JumpStatement        // Case StatementJump
+//	|       AsmStatement         // Case StatementAsm
+type Statement struct {
+	Operand             Operand // Case CompoundStatement, ExpressionStatement
+	AsmStatement        *AsmStatement
+	Case                StatementCase `PrettyPrint:"stringer,zero"`
+	CompoundStatement   *CompoundStatement
+	ExpressionStatement *ExpressionStatement
+	IterationStatement  *IterationStatement
+	JumpStatement       *JumpStatement
+	LabeledStatement    *LabeledStatement
+	SelectionStatement  *SelectionStatement
+}
+
+// String implements fmt.Stringer.
+func (n *Statement) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *Statement) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 6:
+		return n.AsmStatement.Position()
+	case 1:
+		return n.CompoundStatement.Position()
+	case 2:
+		return n.ExpressionStatement.Position()
+	case 4:
+		return n.IterationStatement.Position()
+	case 5:
+		return n.JumpStatement.Position()
+	case 0:
+		return n.LabeledStatement.Position()
+	case 3:
+		return n.SelectionStatement.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// StorageClassSpecifierCase represents case numbers of production StorageClassSpecifier
+type StorageClassSpecifierCase int
+
+// Values of type StorageClassSpecifierCase
+const (
+	StorageClassSpecifierTypedef StorageClassSpecifierCase = iota
+	StorageClassSpecifierExtern
+	StorageClassSpecifierStatic
+	StorageClassSpecifierAuto
+	StorageClassSpecifierRegister
+	StorageClassSpecifierThreadLocal
+)
+
+// String implements fmt.Stringer
+func (n StorageClassSpecifierCase) String() string {
+	switch n {
+	case StorageClassSpecifierTypedef:
+		return "StorageClassSpecifierTypedef"
+	case StorageClassSpecifierExtern:
+		return "StorageClassSpecifierExtern"
+	case StorageClassSpecifierStatic:
+		return "StorageClassSpecifierStatic"
+	case StorageClassSpecifierAuto:
+		return "StorageClassSpecifierAuto"
+	case StorageClassSpecifierRegister:
+		return "StorageClassSpecifierRegister"
+	case StorageClassSpecifierThreadLocal:
+		return "StorageClassSpecifierThreadLocal"
+	default:
+		return fmt.Sprintf("StorageClassSpecifierCase(%v)", int(n))
+	}
+}
+
+// StorageClassSpecifier represents data reduced by productions:
+//
+//	StorageClassSpecifier:
+//	        "typedef"        // Case StorageClassSpecifierTypedef
+//	|       "extern"         // Case StorageClassSpecifierExtern
+//	|       "static"         // Case StorageClassSpecifierStatic
+//	|       "auto"           // Case StorageClassSpecifierAuto
+//	|       "register"       // Case StorageClassSpecifierRegister
+//	|       "_Thread_local"  // Case StorageClassSpecifierThreadLocal
+type StorageClassSpecifier struct {
+	Case  StorageClassSpecifierCase `PrettyPrint:"stringer,zero"`
+	Token Token
+}
+
+// String implements fmt.Stringer.
+func (n *StorageClassSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StorageClassSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// StructDeclaration represents data reduced by production:
+//
+//	StructDeclaration:
+//	        SpecifierQualifierList StructDeclaratorList ';'
+type StructDeclaration struct {
+	Empty                  bool // TCC extension
+	SpecifierQualifierList *SpecifierQualifierList
+	StructDeclaratorList   *StructDeclaratorList
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *StructDeclaration) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructDeclaration) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.SpecifierQualifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	if p := n.StructDeclaratorList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.Token.Position()
+}
+
+// StructDeclarationList represents data reduced by productions:
+//
+//	StructDeclarationList:
+//	        StructDeclaration
+//	|       StructDeclarationList StructDeclaration
+type StructDeclarationList struct {
+	StructDeclaration     *StructDeclaration
+	StructDeclarationList *StructDeclarationList
+}
+
+// String implements fmt.Stringer.
+func (n *StructDeclarationList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructDeclarationList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.StructDeclaration.Position()
+}
+
+// StructDeclaratorCase represents case numbers of production StructDeclarator
+type StructDeclaratorCase int
+
+// Values of type StructDeclaratorCase
+const (
+	StructDeclaratorDecl StructDeclaratorCase = iota
+	StructDeclaratorBitField
+)
+
+// String implements fmt.Stringer
+func (n StructDeclaratorCase) String() string {
+	switch n {
+	case StructDeclaratorDecl:
+		return "StructDeclaratorDecl"
+	case StructDeclaratorBitField:
+		return "StructDeclaratorBitField"
+	default:
+		return fmt.Sprintf("StructDeclaratorCase(%v)", int(n))
+	}
+}
+
+// StructDeclarator represents data reduced by productions:
+//
+//	StructDeclarator:
+//	        Declarator                                                // Case StructDeclaratorDecl
+//	|       Declarator ':' ConstantExpression AttributeSpecifierList  // Case StructDeclaratorBitField
+type StructDeclarator struct {
+	decl                   *StructDeclaration
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   StructDeclaratorCase `PrettyPrint:"stringer,zero"`
+	ConstantExpression     *ConstantExpression
+	Declarator             *Declarator
+	Token                  Token
+}
+
+// String implements fmt.Stringer.
+func (n *StructDeclarator) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructDeclarator) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.Declarator.Position()
+	case 1:
+		if p := n.Declarator.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.ConstantExpression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AttributeSpecifierList.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// StructDeclaratorList represents data reduced by productions:
+//
+//	StructDeclaratorList:
+//	        StructDeclarator
+//	|       StructDeclaratorList ',' StructDeclarator
+type StructDeclaratorList struct {
+	StructDeclarator     *StructDeclarator
+	StructDeclaratorList *StructDeclaratorList
+	Token                Token
+}
+
+// String implements fmt.Stringer.
+func (n *StructDeclaratorList) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructDeclaratorList) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.StructDeclarator.Position()
+}
+
+// StructOrUnionCase represents case numbers of production StructOrUnion
+type StructOrUnionCase int
+
+// Values of type StructOrUnionCase
+const (
+	StructOrUnionStruct StructOrUnionCase = iota
+	StructOrUnionUnion
+)
+
+// String implements fmt.Stringer
+func (n StructOrUnionCase) String() string {
+	switch n {
+	case StructOrUnionStruct:
+		return "StructOrUnionStruct"
+	case StructOrUnionUnion:
+		return "StructOrUnionUnion"
+	default:
+		return fmt.Sprintf("StructOrUnionCase(%v)", int(n))
+	}
+}
+
+// StructOrUnion represents data reduced by productions:
+//
+//	StructOrUnion:
+//	        "struct"  // Case StructOrUnionStruct
+//	|       "union"   // Case StructOrUnionUnion
+type StructOrUnion struct {
+	Case  StructOrUnionCase `PrettyPrint:"stringer,zero"`
+	Token Token
+}
+
+// String implements fmt.Stringer.
+func (n *StructOrUnion) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructOrUnion) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// StructOrUnionSpecifierCase represents case numbers of production StructOrUnionSpecifier
+type StructOrUnionSpecifierCase int
+
+// Values of type StructOrUnionSpecifierCase
+const (
+	StructOrUnionSpecifierDef StructOrUnionSpecifierCase = iota
+	StructOrUnionSpecifierTag
+)
+
+// String implements fmt.Stringer
+func (n StructOrUnionSpecifierCase) String() string {
+	switch n {
+	case StructOrUnionSpecifierDef:
+		return "StructOrUnionSpecifierDef"
+	case StructOrUnionSpecifierTag:
+		return "StructOrUnionSpecifierTag"
+	default:
+		return fmt.Sprintf("StructOrUnionSpecifierCase(%v)", int(n))
+	}
+}
+
+// StructOrUnionSpecifier represents data reduced by productions:
+//
+//	StructOrUnionSpecifier:
+//	        StructOrUnion AttributeSpecifierList IDENTIFIER '{' StructDeclarationList '}'  // Case StructOrUnionSpecifierDef
+//	|       StructOrUnion AttributeSpecifierList IDENTIFIER                                // Case StructOrUnionSpecifierTag
+type StructOrUnionSpecifier struct {
+	lexicalScope           Scope
+	maxAlign               int
+	typ                    Type
+	AttributeSpecifierList *AttributeSpecifierList
+	Case                   StructOrUnionSpecifierCase `PrettyPrint:"stringer,zero"`
+	StructDeclarationList  *StructDeclarationList
+	StructOrUnion          *StructOrUnion
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+}
+
+// String implements fmt.Stringer.
+func (n *StructOrUnionSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *StructOrUnionSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		if p := n.StructOrUnion.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token.Position()
+	case 0:
+		if p := n.StructOrUnion.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.AttributeSpecifierList.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.StructDeclarationList.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// TranslationUnit represents data reduced by productions:
+//
+//	TranslationUnit:
+//	        ExternalDeclaration
+//	|       TranslationUnit ExternalDeclaration
+type TranslationUnit struct {
+	ExternalDeclaration *ExternalDeclaration
+	TranslationUnit     *TranslationUnit
+}
+
+// String implements fmt.Stringer.
+func (n *TranslationUnit) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *TranslationUnit) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.ExternalDeclaration.Position()
+}
+
+// TypeName represents data reduced by production:
+//
+//	TypeName:
+//	        SpecifierQualifierList AbstractDeclarator
+type TypeName struct {
+	typ                    Type
+	AbstractDeclarator     *AbstractDeclarator
+	SpecifierQualifierList *SpecifierQualifierList
+}
+
+// String implements fmt.Stringer.
+func (n *TypeName) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *TypeName) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	if p := n.SpecifierQualifierList.Position(); p.IsValid() {
+		return p
+	}
+
+	return n.AbstractDeclarator.Position()
+}
+
+// TypeQualifierCase represents case numbers of production TypeQualifier
+type TypeQualifierCase int
+
+// Values of type TypeQualifierCase
+const (
+	TypeQualifierConst TypeQualifierCase = iota
+	TypeQualifierRestrict
+	TypeQualifierVolatile
+	TypeQualifierAtomic
+)
+
+// String implements fmt.Stringer
+func (n TypeQualifierCase) String() string {
+	switch n {
+	case TypeQualifierConst:
+		return "TypeQualifierConst"
+	case TypeQualifierRestrict:
+		return "TypeQualifierRestrict"
+	case TypeQualifierVolatile:
+		return "TypeQualifierVolatile"
+	case TypeQualifierAtomic:
+		return "TypeQualifierAtomic"
+	default:
+		return fmt.Sprintf("TypeQualifierCase(%v)", int(n))
+	}
+}
+
+// TypeQualifier represents data reduced by productions:
+//
+//	TypeQualifier:
+//	        "const"     // Case TypeQualifierConst
+//	|       "restrict"  // Case TypeQualifierRestrict
+//	|       "volatile"  // Case TypeQualifierVolatile
+//	|       "_Atomic"   // Case TypeQualifierAtomic
+type TypeQualifier struct {
+	Case  TypeQualifierCase `PrettyPrint:"stringer,zero"`
+	Token Token
+}
+
+// String implements fmt.Stringer.
+func (n *TypeQualifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *TypeQualifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	return n.Token.Position()
+}
+
+// TypeQualifiersCase represents case numbers of production TypeQualifiers
+type TypeQualifiersCase int
+
+// Values of type TypeQualifiersCase
+const (
+	TypeQualifiersTypeQual TypeQualifiersCase = iota
+	TypeQualifiersAttribute
+	_
+	_
+)
+
+// String implements fmt.Stringer
+func (n TypeQualifiersCase) String() string {
+	switch n {
+	case TypeQualifiersTypeQual:
+		return "TypeQualifiersTypeQual"
+	case TypeQualifiersAttribute:
+		return "TypeQualifiersAttribute"
+	default:
+		return fmt.Sprintf("TypeQualifiersCase(%v)", int(n))
+	}
+}
+
+// TypeQualifiers represents data reduced by productions:
+//
+//	TypeQualifiers:
+//	        TypeQualifier                      // Case TypeQualifiersTypeQual
+//	|       AttributeSpecifier                 // Case TypeQualifiersAttribute
+//	|       TypeQualifiers TypeQualifier       // Case 2
+//	|       TypeQualifiers AttributeSpecifier  // Case 3
+type TypeQualifiers struct {
+	noStorageClass
+	AttributeSpecifier *AttributeSpecifier
+	Case               TypeQualifiersCase `PrettyPrint:"stringer,zero"`
+	TypeQualifier      *TypeQualifier
+	TypeQualifiers     *TypeQualifiers
+}
+
+// String implements fmt.Stringer.
+func (n *TypeQualifiers) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *TypeQualifiers) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 1:
+		return n.AttributeSpecifier.Position()
+	case 0:
+		return n.TypeQualifier.Position()
+	case 3:
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.AttributeSpecifier.Position()
+	case 2:
+		if p := n.TypeQualifiers.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.TypeQualifier.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// TypeSpecifierCase represents case numbers of production TypeSpecifier
+type TypeSpecifierCase int
+
+// Values of type TypeSpecifierCase
+const (
+	TypeSpecifierVoid TypeSpecifierCase = iota
+	TypeSpecifierChar
+	TypeSpecifierShort
+	TypeSpecifierInt
+	TypeSpecifierInt8
+	TypeSpecifierInt16
+	TypeSpecifierInt32
+	TypeSpecifierInt64
+	TypeSpecifierInt128
+	TypeSpecifierLong
+	TypeSpecifierFloat
+	TypeSpecifierFloat16
+	TypeSpecifierDecimal32
+	TypeSpecifierDecimal64
+	TypeSpecifierDecimal128
+	TypeSpecifierFloat128
+	TypeSpecifierFloat80
+	TypeSpecifierDouble
+	TypeSpecifierSigned
+	TypeSpecifierUnsigned
+	TypeSpecifierBool
+	TypeSpecifierComplex
+	TypeSpecifierStructOrUnion
+	TypeSpecifierEnum
+	TypeSpecifierTypedefName
+	TypeSpecifierTypeofExpr
+	TypeSpecifierTypeofType
+	TypeSpecifierAtomic
+	TypeSpecifierFract
+	TypeSpecifierSat
+	TypeSpecifierAccum
+	TypeSpecifierFloat32
+	TypeSpecifierFloat64
+	TypeSpecifierFloat32x
+	TypeSpecifierFloat64x
+)
+
+// String implements fmt.Stringer
+func (n TypeSpecifierCase) String() string {
+	switch n {
+	case TypeSpecifierVoid:
+		return "TypeSpecifierVoid"
+	case TypeSpecifierChar:
+		return "TypeSpecifierChar"
+	case TypeSpecifierShort:
+		return "TypeSpecifierShort"
+	case TypeSpecifierInt:
+		return "TypeSpecifierInt"
+	case TypeSpecifierInt8:
+		return "TypeSpecifierInt8"
+	case TypeSpecifierInt16:
+		return "TypeSpecifierInt16"
+	case TypeSpecifierInt32:
+		return "TypeSpecifierInt32"
+	case TypeSpecifierInt64:
+		return "TypeSpecifierInt64"
+	case TypeSpecifierInt128:
+		return "TypeSpecifierInt128"
+	case TypeSpecifierLong:
+		return "TypeSpecifierLong"
+	case TypeSpecifierFloat:
+		return "TypeSpecifierFloat"
+	case TypeSpecifierFloat16:
+		return "TypeSpecifierFloat16"
+	case TypeSpecifierDecimal32:
+		return "TypeSpecifierDecimal32"
+	case TypeSpecifierDecimal64:
+		return "TypeSpecifierDecimal64"
+	case TypeSpecifierDecimal128:
+		return "TypeSpecifierDecimal128"
+	case TypeSpecifierFloat128:
+		return "TypeSpecifierFloat128"
+	case TypeSpecifierFloat80:
+		return "TypeSpecifierFloat80"
+	case TypeSpecifierDouble:
+		return "TypeSpecifierDouble"
+	case TypeSpecifierSigned:
+		return "TypeSpecifierSigned"
+	case TypeSpecifierUnsigned:
+		return "TypeSpecifierUnsigned"
+	case TypeSpecifierBool:
+		return "TypeSpecifierBool"
+	case TypeSpecifierComplex:
+		return "TypeSpecifierComplex"
+	case TypeSpecifierStructOrUnion:
+		return "TypeSpecifierStructOrUnion"
+	case TypeSpecifierEnum:
+		return "TypeSpecifierEnum"
+	case TypeSpecifierTypedefName:
+		return "TypeSpecifierTypedefName"
+	case TypeSpecifierTypeofExpr:
+		return "TypeSpecifierTypeofExpr"
+	case TypeSpecifierTypeofType:
+		return "TypeSpecifierTypeofType"
+	case TypeSpecifierAtomic:
+		return "TypeSpecifierAtomic"
+	case TypeSpecifierFract:
+		return "TypeSpecifierFract"
+	case TypeSpecifierSat:
+		return "TypeSpecifierSat"
+	case TypeSpecifierAccum:
+		return "TypeSpecifierAccum"
+	case TypeSpecifierFloat32:
+		return "TypeSpecifierFloat32"
+	case TypeSpecifierFloat64:
+		return "TypeSpecifierFloat64"
+	case TypeSpecifierFloat32x:
+		return "TypeSpecifierFloat32x"
+	case TypeSpecifierFloat64x:
+		return "TypeSpecifierFloat64x"
+	default:
+		return fmt.Sprintf("TypeSpecifierCase(%v)", int(n))
+	}
+}
+
+// TypeSpecifier represents data reduced by productions:
+//
+//	TypeSpecifier:
+//	        "void"                       // Case TypeSpecifierVoid
+//	|       "char"                       // Case TypeSpecifierChar
+//	|       "short"                      // Case TypeSpecifierShort
+//	|       "int"                        // Case TypeSpecifierInt
+//	|       "__int8"                     // Case TypeSpecifierInt8
+//	|       "__int16"                    // Case TypeSpecifierInt16
+//	|       "__int32"                    // Case TypeSpecifierInt32
+//	|       "__int64"                    // Case TypeSpecifierInt64
+//	|       "__int128"                   // Case TypeSpecifierInt128
+//	|       "long"                       // Case TypeSpecifierLong
+//	|       "float"                      // Case TypeSpecifierFloat
+//	|       "__fp16"                     // Case TypeSpecifierFloat16
+//	|       "_Decimal32"                 // Case TypeSpecifierDecimal32
+//	|       "_Decimal64"                 // Case TypeSpecifierDecimal64
+//	|       "_Decimal128"                // Case TypeSpecifierDecimal128
+//	|       "_Float128"                  // Case TypeSpecifierFloat128
+//	|       "__float80"                  // Case TypeSpecifierFloat80
+//	|       "double"                     // Case TypeSpecifierDouble
+//	|       "signed"                     // Case TypeSpecifierSigned
+//	|       "unsigned"                   // Case TypeSpecifierUnsigned
+//	|       "_Bool"                      // Case TypeSpecifierBool
+//	|       "_Complex"                   // Case TypeSpecifierComplex
+//	|       StructOrUnionSpecifier       // Case TypeSpecifierStructOrUnion
+//	|       EnumSpecifier                // Case TypeSpecifierEnum
+//	|       TYPEDEFNAME                  // Case TypeSpecifierTypedefName
+//	|       "typeof" '(' Expression ')'  // Case TypeSpecifierTypeofExpr
+//	|       "typeof" '(' TypeName ')'    // Case TypeSpecifierTypeofType
+//	|       AtomicTypeSpecifier          // Case TypeSpecifierAtomic
+//	|       "_Fract"                     // Case TypeSpecifierFract
+//	|       "_Sat"                       // Case TypeSpecifierSat
+//	|       "_Accum"                     // Case TypeSpecifierAccum
+//	|       "_Float32"                   // Case TypeSpecifierFloat32
+//	|       "_Float64"                   // Case TypeSpecifierFloat64
+//	|       "_Float32x"                  // Case TypeSpecifierFloat32x
+//	|       "_Float64x"                  // Case TypeSpecifierFloat64x
+type TypeSpecifier struct {
+	resolvedIn             Scope // Case TypedefName
+	typ                    Type
+	AtomicTypeSpecifier    *AtomicTypeSpecifier
+	Case                   TypeSpecifierCase `PrettyPrint:"stringer,zero"`
+	EnumSpecifier          *EnumSpecifier
+	Expression             *Expression
+	StructOrUnionSpecifier *StructOrUnionSpecifier
+	Token                  Token
+	Token2                 Token
+	Token3                 Token
+	TypeName               *TypeName
+}
+
+// String implements fmt.Stringer.
+func (n *TypeSpecifier) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *TypeSpecifier) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 27:
+		return n.AtomicTypeSpecifier.Position()
+	case 23:
+		return n.EnumSpecifier.Position()
+	case 22:
+		return n.StructOrUnionSpecifier.Position()
+	case 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 28, 29, 30, 31, 32, 33, 34:
+		return n.Token.Position()
+	case 25:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Expression.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 26:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	default:
+		panic("internal error")
+	}
+}
+
+// UnaryExpressionCase represents case numbers of production UnaryExpression
+type UnaryExpressionCase int
+
+// Values of type UnaryExpressionCase
+const (
+	UnaryExpressionPostfix UnaryExpressionCase = iota
+	UnaryExpressionInc
+	UnaryExpressionDec
+	UnaryExpressionAddrof
+	UnaryExpressionDeref
+	UnaryExpressionPlus
+	UnaryExpressionMinus
+	UnaryExpressionCpl
+	UnaryExpressionNot
+	UnaryExpressionSizeofExpr
+	UnaryExpressionSizeofType
+	UnaryExpressionLabelAddr
+	UnaryExpressionAlignofExpr
+	UnaryExpressionAlignofType
+	UnaryExpressionImag
+	UnaryExpressionReal
+)
+
+// String implements fmt.Stringer
+func (n UnaryExpressionCase) String() string {
+	switch n {
+	case UnaryExpressionPostfix:
+		return "UnaryExpressionPostfix"
+	case UnaryExpressionInc:
+		return "UnaryExpressionInc"
+	case UnaryExpressionDec:
+		return "UnaryExpressionDec"
+	case UnaryExpressionAddrof:
+		return "UnaryExpressionAddrof"
+	case UnaryExpressionDeref:
+		return "UnaryExpressionDeref"
+	case UnaryExpressionPlus:
+		return "UnaryExpressionPlus"
+	case UnaryExpressionMinus:
+		return "UnaryExpressionMinus"
+	case UnaryExpressionCpl:
+		return "UnaryExpressionCpl"
+	case UnaryExpressionNot:
+		return "UnaryExpressionNot"
+	case UnaryExpressionSizeofExpr:
+		return "UnaryExpressionSizeofExpr"
+	case UnaryExpressionSizeofType:
+		return "UnaryExpressionSizeofType"
+	case UnaryExpressionLabelAddr:
+		return "UnaryExpressionLabelAddr"
+	case UnaryExpressionAlignofExpr:
+		return "UnaryExpressionAlignofExpr"
+	case UnaryExpressionAlignofType:
+		return "UnaryExpressionAlignofType"
+	case UnaryExpressionImag:
+		return "UnaryExpressionImag"
+	case UnaryExpressionReal:
+		return "UnaryExpressionReal"
+	default:
+		return fmt.Sprintf("UnaryExpressionCase(%v)", int(n))
+	}
+}
+
+// UnaryExpression represents data reduced by productions:
+//
+//	UnaryExpression:
+//	        PostfixExpression            // Case UnaryExpressionPostfix
+//	|       "++" UnaryExpression         // Case UnaryExpressionInc
+//	|       "--" UnaryExpression         // Case UnaryExpressionDec
+//	|       '&' CastExpression           // Case UnaryExpressionAddrof
+//	|       '*' CastExpression           // Case UnaryExpressionDeref
+//	|       '+' CastExpression           // Case UnaryExpressionPlus
+//	|       '-' CastExpression           // Case UnaryExpressionMinus
+//	|       '~' CastExpression           // Case UnaryExpressionCpl
+//	|       '!' CastExpression           // Case UnaryExpressionNot
+//	|       "sizeof" UnaryExpression     // Case UnaryExpressionSizeofExpr
+//	|       "sizeof" '(' TypeName ')'    // Case UnaryExpressionSizeofType
+//	|       "&&" IDENTIFIER              // Case UnaryExpressionLabelAddr
+//	|       "_Alignof" UnaryExpression   // Case UnaryExpressionAlignofExpr
+//	|       "_Alignof" '(' TypeName ')'  // Case UnaryExpressionAlignofType
+//	|       "__imag__" UnaryExpression   // Case UnaryExpressionImag
+//	|       "__real__" UnaryExpression   // Case UnaryExpressionReal
+type UnaryExpression struct {
+	Operand           Operand
+	lexicalScope      Scope
+	IsSideEffectsFree bool
+	Case              UnaryExpressionCase `PrettyPrint:"stringer,zero"`
+	CastExpression    *CastExpression
+	PostfixExpression *PostfixExpression
+	Token             Token
+	Token2            Token
+	Token3            Token
+	TypeName          *TypeName
+	UnaryExpression   *UnaryExpression
+}
+
+// String implements fmt.Stringer.
+func (n *UnaryExpression) String() string { return PrettyString(n) }
+
+// Position reports the position of the first component of n, if available.
+func (n *UnaryExpression) Position() (r token.Position) {
+	if n == nil {
+		return r
+	}
+
+	switch n.Case {
+	case 0:
+		return n.PostfixExpression.Position()
+	case 3, 4, 5, 6, 7, 8:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.CastExpression.Position()
+	case 11:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token2.Position()
+	case 10, 13:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.Token2.Position(); p.IsValid() {
+			return p
+		}
+
+		if p := n.TypeName.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.Token3.Position()
+	case 1, 2, 9, 12, 14, 15:
+		if p := n.Token.Position(); p.IsValid() {
+			return p
+		}
+
+		return n.UnaryExpression.Position()
+	default:
+		panic("internal error")
+	}
+}