d4.dlr

%{
	BasicType2 := lbrack AssignExpression rbrack;
	DeclaratorSuffix := lbrack AssignExpression rback;
}%

%{
	Declarator := identifier;
	TemplateTypeParameter := identifier;
}%

%{
	PrimaryExpression := line;
	DefaultInitializerExpression;
}%

%{
	IdentifierList := TemplateInstance;
	SymbolTail := TemplateInstance;
}%

%{
	BasicType2 := lbrack Type rbrack;
	DeclaratorSuffix := lbrack Type rbrack;
}%

%right abstract auto const deprecated extern final immutable inout shared nothrow override pure ref scope static synchronized gshared thread
%left assign plusassign minusassign starassign divassign moduloassign orassign andassign xorassign tildeassign leftshiftassign rightshiftassign unsignedrightshiftassign xorxorassign
%right dot
%right comma
%right logicalor
%right logicaland
%right or
%right xor
%right and
%right equal notequal bangis is bangin in
%right less greater lessequal greaterequal
%right leftshift rightshift
%right plus minus
%right star div modulo
%right increment decrement bang tilde
%right lparen rparen lbrack rbrack

S := Module;
	{: ret = buildTreeWithLoc(termS, [-1], actionNum,
		this.tokenStack[-1].getLoc()); :}

// checked
Module :=
	ModuleDeclaration DeclDefs; 
		{: ret = buildTreeWithLoc(termModule, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| DeclDefs;
		{: ret = buildTreeWithLoc(termModule, [-1], actionNum, 
			this.tokenStack[-1].getLoc()); :}

// checked
ModuleDeclaration :=
	module ModuleFullyQualifiedName semicolon; 
		{: ret = buildTreeWithLoc(termModuleDeclaration, [-2], actionNum,
		this.tokenStack[-3].getLoc()); :}

// checked
ModuleFullyQualifiedName :=
	ModuleName;
		{: ret = buildTreeWithLoc(termModuleFullyQualifiedName, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Packages dot ModuleName; 
		{: ret = buildTreeWithLoc(termModuleFullyQualifiedName, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ModuleName :=
	identifier;
		{: ret = buildTreeWithLoc(termModuleName, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Packages :=
	PackageName;
		{: ret = buildTreeWithLoc(termPackages, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Packages dot PackageName; 
		{: ret = buildTreeWithLoc(termPackages, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
PackageName :=
	identifier;
		{: ret = buildTreeWithLoc(termPackageName, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
DeclDefs :=
	DeclDef;
		{: ret = buildTreeWithLoc(termDeclDefs, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeclDef DeclDefs; 
		{: ret = buildTreeWithLoc(termDeclDefs, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
DeclDef :=
	AttributeSpecifier;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ImportDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| EnumDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ClassDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| InterfaceDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AggregateDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Declaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Constructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Destructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| UnitTest;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StaticConstructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StaticDestructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| SharedStaticConstructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| SharedStaticDestructor;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ConditionalDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DebugSpecification;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| VersionSpecification;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StaticAssert;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateMixinDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateMixin;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| MixinDeclaration;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| semicolon;
		{: ret = buildTreeWithLoc(termDeclDef, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ImportDeclaration :=
	import ImportList semicolon; 
		{: ret = buildTreeWithLoc(termImportDeclaration, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}

	| static import ImportList semicolon; 
		{: ret = buildTreeWithLoc(termImportDeclaration, [-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}

// checked
ImportList :=
	Import; 
		{: ret = buildTreeWithLoc(termImportList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ImportBindings; 
		{: ret = buildTreeWithLoc(termImportList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Import comma ImportList; 
		{: ret = buildTreeWithLoc(termImportList, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
Import :=
	ModuleFullyQualifiedName; 
		{: ret = buildTreeWithLoc(termImport, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ModuleAliasIdentifier assign ModuleFullyQualifiedName; 
		{: ret = buildTreeWithLoc(termImport, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
ImportBindings :=
	Import colon ImportBindList; 
		{: ret = buildTreeWithLoc(termImportBindings, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
ImportBindList :=
	ImportBind;
		{: ret = buildTreeWithLoc(termImportBindList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ImportBind comma ImportBindList; 
		{: ret = buildTreeWithLoc(termImportBindList, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
ImportBind :=
	identifier;
		{: ret = buildTreeWithLoc(termImportBind, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier assign identifier; 
		{: ret = buildTreeWithLoc(termImportBind, [-3,-1], actionNum,
			this.tokenStack[-2].getLoc()); :}

// checked
ModuleAliasIdentifier :=
	identifier;
		{: ret = buildTreeWithLoc(termModuleAliasIdentifier, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
MixinDeclaration :=
	mixin lparen AssignExpression rparen semicolon; 
		{: ret = buildTreeWithLoc(termMixinDeclaration, [-3], actionNum,
			this.tokenStack[-5].getLoc()); :}

// checked
Declaration :=
	AliasDeclaration;
		{: ret = buildTreeWithLoc(termDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AliasThisDeclaration;
		{: ret = buildTreeWithLoc(termDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Decl;
		{: ret = buildTreeWithLoc(termDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
AliasDeclaration :=
	alias BasicType Declarator; 
		{: ret = buildTreeWithLoc(termAliasDeclaration, [-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	
// checked
AliasThisDeclaration := 
	alias identifier this;
		{: ret = buildTreeWithLoc(termAliasThisDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
Decl := 
	StorageClasses Decl; 
		{: ret = buildTreeWithLoc(termDecl, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| BasicType Declarators semicolon; 
		{: ret = buildTreeWithLoc(termDecl, [-3,-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| BasicType Declarator {: 
			this.dontPopToken = true; 
			this.openScope(-1,-2); :} FunctionBody; 
		{: ret = buildTreeWithLoc(termDecl, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc());
			this.closeScope(); :}
	| AutoDeclaration;
		{: ret = buildTreeWithLoc(termDecl, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Declarators :=
	DeclaratorInitializer;
		{: ret = buildTreeWithLoc(termDeclarators, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeclaratorInitializer comma DeclaratorIdentifierList; 
		{: ret = buildTreeWithLoc(termDeclarators, [-3,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
DeclaratorInitializer :=
	Declarator;
		{: ret = buildTreeWithLoc(termDeclaratorInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Declarator assign Initializer;
		{: ret = buildTreeWithLoc(termDeclaratorInitializer, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
DeclaratorIdentifierList :=
	DeclaratorIdentifier;
		{: ret = buildTreeWithLoc(termDeclaratorIdentifierList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeclaratorIdentifier comma DeclaratorIdentifierList;
		{: ret = buildTreeWithLoc(termDeclaratorIdentifierList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
DeclaratorIdentifier :=
	identifier;
		{: ret = buildTreeWithLoc(termDeclaratorIdentifier, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier assign Initializer;
		{: ret = buildTreeWithLoc(termDeclaratorIdentifier, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AutoDeclaration := 
	StorageClasses AutoDeclarationX semicolon; 
		{: ret = buildTreeWithLoc(termAutoDeclaration, [-3,-2], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	
// checked
AutoDeclarationX := 
	identifier assign Initializer;
		{: ret = buildTreeWithLoc(termAutoDeclarationX, [-3,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| AutoDeclarationX comma identifier assign Initializer;
		{: ret = buildTreeWithLoc(termAutoDeclarationX, [-5,-3,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
BasicType :=
	BasicTypeX;
		{: ret = buildTreeWithLoc(termBasicType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dot IdentifierList; 
		{: ret = buildTreeWithLoc(termBasicType, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| IdentifierList;
		{: ret = buildTreeWithLoc(termBasicType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Typeof;
		{: ret = buildTreeWithLoc(termBasicType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Typeof dot IdentifierList;
		{: ret = buildTreeWithLoc(termBasicType, [-3,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| const lparen Type rparen;
		{: ret = buildTreeWithLoc(termBasicType, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| immutable lparen Type rparen;
		{: ret = buildTreeWithLoc(termBasicType, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| shared lparen Type rparen;
		{: ret = buildTreeWithLoc(termBasicType, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| inout lparen Type rparen;
		{: ret = buildTreeWithLoc(termBasicType, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}

// checked
BasicTypeX :=
	bool;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| byte;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ubyte;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| short;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ushort;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| int;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| uint;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| long;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ulong;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| char;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| wchar;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dchar;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| float;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| size_t;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| double;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| real;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ifloat;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| idouble;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ireal;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| cfloat;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| cdouble;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| creal;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| void;
		{: ret = buildTreeWithLoc(termBasicTypeX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
BasicType2 :=
	star;
		{: ret = buildTreeWithLoc(termBasicType2, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lbrack rbrack ;
		{: ret = buildTreeWithLoc(termBasicType2, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| lbrack AssignExpression rbrack ;
		{: ret = buildTreeWithLoc(termBasicType2, [-3,-1], actionNum, 
			this.tokenStack[-1].getLoc()); :}
	| lbrack AssignExpression dotdot AssignExpression rbrack;
		{: ret = buildTreeWithLoc(termBasicType2, [-4,-3,-2], actionNum, 
			this.tokenStack[-5].getLoc()); :}
	| lbrack Type rbrack ;
		{: ret = buildTreeWithLoc(termBasicType2, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| delegate Parameters FunctionAttributes;
		{: ret = buildTreeWithLoc(termBasicType2, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| function Parameters FunctionAttributes;
		{: ret = buildTreeWithLoc(termBasicType2, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| delegate Parameters;
		{: ret = buildTreeWithLoc(termBasicType2, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| function Parameters;
		{: ret = buildTreeWithLoc(termBasicType2, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
Declarator :=
	BasicType2 identifier;
		{: ret = buildTreeWithLoc(termDeclarator, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| BasicType2 identifier DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| BasicType2 lparen Declarator rparen;
		{: ret = buildTreeWithLoc(termDeclarator, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| BasicType2 lparen Declarator rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator, [-5,-3,-1], actionNum, 
			this.tokenStack[-5].getLoc()); :}
	| identifier ;
		{: ret = buildTreeWithLoc(termDeclarator, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| lparen Declarator rparen;
		{: ret = buildTreeWithLoc(termDeclarator, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| lparen Declarator rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator, [-3,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}

// checked
DeclaratorSuffixes :=
	DeclaratorSuffix;
		{: ret = buildTreeWithLoc(termDeclaratorSuffixes, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeclaratorSuffix DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclaratorSuffixes, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
DeclaratorSuffix :=
	lbrack rbrack;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| lbrack AssignExpression rbrack;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| lbrack Type rbrack;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| Parameters;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Parameters Constraint;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| Parameters MemberFunctionAttributes Constraint;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| Parameters MemberFunctionAttributes;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| TemplateParameterList Parameters Constraint;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| TemplateParameterList Parameters MemberFunctionAttributes;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| TemplateParameterList Parameters MemberFunctionAttributes Constraint;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| TemplateParameterList Parameters;
		{: ret = buildTreeWithLoc(termDeclaratorSuffix, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
IdentifierList :=
	identifier ;
		{: ret = buildTreeWithLoc(termIdentifierList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier dot IdentifierList; 
		{: ret = buildTreeWithLoc(termIdentifierList, [-3,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| TemplateInstance ;
		{: ret = buildTreeWithLoc(termIdentifierList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateInstance dot IdentifierList; 
		{: ret = buildTreeWithLoc(termIdentifierList, [-3,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
StorageClasses :=
	StorageClass;
		{: ret = buildTreeWithLoc(termStorageClasses, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StorageClass StorageClasses;
		{: ret = buildTreeWithLoc(termStorageClasses, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
StorageClass :=
	abstract;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| auto;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| const;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| deprecated;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| enum;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| extern;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| final;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| nothrow;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| override;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| pure;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| gshared;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Property;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| scope;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| static;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| synchronized;
		{: ret = buildTreeWithLoc(termStorageClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Property :=
	disable;
		{: ret = buildTreeWithLoc(termProperty, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| safe;
		{: ret = buildTreeWithLoc(termProperty, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| system;
		{: ret = buildTreeWithLoc(termProperty, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| trusted;
		{: ret = buildTreeWithLoc(termProperty, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| property;
		{: ret = buildTreeWithLoc(termProperty, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Type :=
	BasicType;
		{: ret = buildTreeWithLoc(termType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| BasicType Declarator2;
		{: ret = buildTreeWithLoc(termType, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
Declarator2 :=
	BasicType2 DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| BasicType2;
		{: ret = buildTreeWithLoc(termDeclarator2, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| BasicType2 lparen Declarator2 rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-5,-3,-1], actionNum, 
			this.tokenStack[-5].getLoc()); :}
	| lparen Declarator2 rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-3,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| BasicType2 lparen Declarator2 rparen;
		{: ret = buildTreeWithLoc(termDeclarator2, [-4,-2], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| lparen Declarator2 rparen;
		{: ret = buildTreeWithLoc(termDeclarator2, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| BasicType2 lparen rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-4,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| lparen rparen DeclaratorSuffixes;
		{: ret = buildTreeWithLoc(termDeclarator2, [-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| BasicType2 lparen rparen;
		{: ret = buildTreeWithLoc(termDeclarator2, [-3], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| lparen rparen;
		{: ret = buildTreeWithLoc(termDeclarator2, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
Parameters :=
	lparen ParameterList rparen;
		{: ret = buildTreeWithLoc(termParameters, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| lparen rparen;
		{: ret = buildTreeWithLoc(termParameters, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
ParameterList :=
	Parameter;
		{: ret = buildTreeWithLoc(termParameterList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Parameter comma ParameterList;
		{: ret = buildTreeWithLoc(termParameterList, [-3,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| dotdotdot;
		{: ret = buildTreeWithLoc(termParameterList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Parameter :=
	InOut BasicType Declarator;
		{: ret = buildTreeWithLoc(termParameter, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| InOut BasicType Declarator dotdotdot;
		{: ret = buildTreeWithLoc(termParameter, [-4,-3,-2,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| InOut BasicType Declarator assign DefaultInitializerExpression;
		{: ret = buildTreeWithLoc(termParameter, [-5,-4,-3,-2,-1], actionNum, 
			this.tokenStack[-5].getLoc()); :}
	| InOut Type;
		{: ret = buildTreeWithLoc(termParameter, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| InOut Type dotdotdot;
		{: ret = buildTreeWithLoc(termParameter, [-3,-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| BasicType Declarator;
		{: ret = buildTreeWithLoc(termParameter, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| BasicType Declarator dotdotdot;
		{: ret = buildTreeWithLoc(termParameter, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| BasicType Declarator assign DefaultInitializerExpression;
		{: ret = buildTreeWithLoc(termParameter, [-4,-3,-2,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}
	| Type;
		{: ret = buildTreeWithLoc(termParameter, [-1], actionNum, 
			this.tokenStack[-1].getLoc()); :}
	| Type dotdotdot;
		{: ret = buildTreeWithLoc(termParameter, [-2,-1], actionNum, 
			this.tokenStack[-1].getLoc()); :}

// checked
InOut :=
	InOutX;
		{: ret = buildTreeWithLoc(termInOut, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| InOut InOutX;
		{: ret = buildTreeWithLoc(termInOut, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
InOutX :=
	auto;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| const;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| final;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| in;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lazy;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| out;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ref;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| scope;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termInOutX, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
FunctionAttributes :=
	FunctionAttribute;
		{: ret = buildTreeWithLoc(termFunctionAttributes, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| FunctionAttribute FunctionAttributes;
		{: ret = buildTreeWithLoc(termFunctionAttributes, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
FunctionAttribute :=
	nothrow;
		{: ret = buildTreeWithLoc(termFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| pure;
		{: ret = buildTreeWithLoc(termFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Property;
		{: ret = buildTreeWithLoc(termFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
MemberFunctionAttributes :=
	MemberFunctionAttribute;
		{: ret = buildTreeWithLoc(termMemberFunctionAttributes, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| MemberFunctionAttribute MemberFunctionAttributes;
		{: ret = buildTreeWithLoc(termMemberFunctionAttributes, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
MemberFunctionAttribute :=
	const;
		{: ret = buildTreeWithLoc(termMemberFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termMemberFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termMemberFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termMemberFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| FunctionAttribute;
		{: ret = buildTreeWithLoc(termMemberFunctionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
DefaultInitializerExpression := 
	AssignExpression;
		{: ret = buildTreeWithLoc(termDefaultInitializerExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| file;
		{: ret = buildTreeWithLoc(termDefaultInitializerExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| line;
		{: ret = buildTreeWithLoc(termDefaultInitializerExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Initializer :=
	VoidInitializer;
		{: ret = buildTreeWithLoc(termInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| NonVoidInitializer;
		{: ret = buildTreeWithLoc(termInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NonVoidInitializer :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termNonVoidInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ArrayInitializer;
		{: ret = buildTreeWithLoc(termNonVoidInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructInitializer;
		{: ret = buildTreeWithLoc(termNonVoidInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ArrayInitializer :=
	lbrack rbrack;
		{: ret = buildTreeWithLoc(termArrayInitializer, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| lbrack ArrayMemberInitializations rbrack;
		{: ret = buildTreeWithLoc(termArrayInitializer, [-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ArrayMemberInitializations :=
	ArrayMemberInitialization;
		{: ret = buildTreeWithLoc(termArrayMemberInitializations, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ArrayMemberInitialization comma;
		{: ret = buildTreeWithLoc(termArrayMemberInitializations, [-2], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ArrayMemberInitialization comma ArrayMemberInitializations;
		{: ret = buildTreeWithLoc(termArrayMemberInitializations, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ArrayMemberInitialization :=
	NonVoidInitializer;
		{: ret = buildTreeWithLoc(termArrayMemberInitialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssignExpression colon NonVoidInitializer;
		{: ret = buildTreeWithLoc(termArrayMemberInitialization, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
StructInitializer :=
	lcurly rcurly;
		{: ret = buildTreeWithLoc(termStructInitializer, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| lcurly StructMemberInitializers rcurly;
		{: ret = buildTreeWithLoc(termStructInitializer, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
StructMemberInitializers :=
	StructMemberInitializer;
		{: ret = buildTreeWithLoc(termStructMemberInitializers, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructMemberInitializer comma;
		{: ret = buildTreeWithLoc(termStructMemberInitializers, [-2], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| StructMemberInitializers comma StructMemberInitializer;
		{: ret = buildTreeWithLoc(termStructMemberInitializers, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
StructMemberInitializer :=
	NonVoidInitializer;
		{: ret = buildTreeWithLoc(termStructMemberInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier colon NonVoidInitializer;
		{: ret = buildTreeWithLoc(termStructMemberInitializer, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
Typeof :=
	typeof lparen Expression rparen;
		{: ret = buildTreeWithLoc(termTypeof, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| typeof lparen return rparen;
		{: ret = buildTreeWithLoc(termTypeof, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
VoidInitializer :=
	void;
		{: ret = buildTreeWithLoc(termVoidInitializer, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
AttributeSpecifier :=
	Attribute colon;
		{: ret = buildTreeWithLoc(termAttributeSpecifier, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| Attribute DeclarationBlock;
		{: ret = buildTreeWithLoc(termAttributeSpecifier, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
Attribute :=
	LinkageAttribute;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AlignAttribute;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Pragma;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| deprecated;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ProtectionAttribute;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| static;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| extern;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| final;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| synchronized;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| override;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| abstract;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| const;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| auto;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| scope;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| gshared;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| disable;
		{: ret = buildTreeWithLoc(termAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
DeclarationBlock :=
	DeclDef;
		{: ret = buildTreeWithLoc(termDeclarationBlock, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termDeclarationBlock, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lcurly rcurly;
		{: ret = buildTreeWithLoc(termDeclarationBlock, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
LinkageAttribute :=
	extern lparen identifier rparen;
		{: ret = buildTreeWithLoc(termLinkageAttribute, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
AlignAttribute :=
	align;
		{: ret = buildTreeWithLoc(termAlignAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| align lparen integer rparen;
		{: ret = buildTreeWithLoc(termAlignAttribute, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
ProtectionAttribute :=
	export;
		{: ret = buildTreeWithLoc(termProtectionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| package;
		{: ret = buildTreeWithLoc(termProtectionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| private;
		{: ret = buildTreeWithLoc(termProtectionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| protected;
		{: ret = buildTreeWithLoc(termProtectionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| public;
		{: ret = buildTreeWithLoc(termProtectionAttribute, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Pragma :=
	pragma lparen identifier rparen;
		{: ret = buildTreeWithLoc(termPragma, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| pragma lparen identifier comma ArgumentList rparen;
		{: ret = buildTreeWithLoc(termPragma, [-4,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
Expression :=
	CommaExpression;
		{: ret = buildTreeWithLoc(termExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
CommaExpression :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termCommaExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssignExpression comma CommaExpression;
		{: ret = buildTreeWithLoc(termCommaExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AssignExpression :=
	ConditionalExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ConditionalExpression assign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression plusassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression minusassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression starassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression divassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression moduloassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression andassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression orassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression xorassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression tildeassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression leftshiftassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression rightshiftassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression unsignedrightshiftassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ConditionalExpression xorxorassign AssignExpression;
		{: ret = buildTreeWithLoc(termAssignExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ConditionalExpression :=
	OrOrExpression;
		{: ret = buildTreeWithLoc(termConditionalExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| OrOrExpression questionmark Expression colon ConditionalExpression;
		{: ret = buildTreeWithLoc(termConditionalExpression, [-5,-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
OrOrExpression :=
	AndAndExpression;
		{: ret = buildTreeWithLoc(termOrOrExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| OrOrExpression logicalor AndAndExpression;
		{: ret = buildTreeWithLoc(termOrOrExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AndAndExpression :=
	OrExpression;
		{: ret = buildTreeWithLoc(termAndAndExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AndAndExpression logicaland OrExpression;
		{: ret = buildTreeWithLoc(termAndAndExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| CmpExpression;
		{: ret = buildTreeWithLoc(termAndAndExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AndAndExpression logicaland CmpExpression;
		{: ret = buildTreeWithLoc(termAndAndExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
OrExpression :=
	XorExpression;
		{: ret = buildTreeWithLoc(termOrExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| OrExpression or XorExpression;
		{: ret = buildTreeWithLoc(termOrExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
XorExpression :=
	AndExpression;
		{: ret = buildTreeWithLoc(termXorExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| XorExpression xor AndExpression;
		{: ret = buildTreeWithLoc(termXorExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AndExpression :=
	ShiftExpression ;
		{: ret = buildTreeWithLoc(termAndExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AndExpression and ShiftExpression;
		{: ret = buildTreeWithLoc(termAndExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
CmpExpression :=
	ShiftExpression;
		{: ret = buildTreeWithLoc(termCmpExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| EqualExpression;
		{: ret = buildTreeWithLoc(termCmpExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| IdentityExpression;
		{: ret = buildTreeWithLoc(termCmpExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| RelExpression;
		{: ret = buildTreeWithLoc(termCmpExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| InExpression;
		{: ret = buildTreeWithLoc(termCmpExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
EqualExpression :=
	ShiftExpression equal ShiftExpression;
		{: ret = buildTreeWithLoc(termEqualExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression notequal ShiftExpression;
		{: ret = buildTreeWithLoc(termEqualExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
IdentityExpression :=
	ShiftExpression is ShiftExpression;
		{: ret = buildTreeWithLoc(termIdentityExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression bangis ShiftExpression;
		{: ret = buildTreeWithLoc(termIdentityExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
RelExpression :=
	ShiftExpression less ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression lessequal ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression greater ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression greaterequal ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression bangsquareassign ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression bangsquare ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression square ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression squareassign ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression banggreater ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression banggreaterassign ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression bangless ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression banglessequal ShiftExpression;
		{: ret = buildTreeWithLoc(termRelExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
InExpression :=
	ShiftExpression in ShiftExpression;
		{: ret = buildTreeWithLoc(termInExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression bangin ShiftExpression;
		{: ret = buildTreeWithLoc(termInExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ShiftExpression :=
	AddExpression;
		{: ret = buildTreeWithLoc(termShiftExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ShiftExpression leftshift AddExpression;
		{: ret = buildTreeWithLoc(termShiftExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression rightshift AddExpression;
		{: ret = buildTreeWithLoc(termShiftExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ShiftExpression unsignedrightshift AddExpression;
		{: ret = buildTreeWithLoc(termShiftExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AddExpression :=
	MulExpression;
		{: ret = buildTreeWithLoc(termAddExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| CatExpression;
		{: ret = buildTreeWithLoc(termAddExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AddExpression plus MulExpression;
		{: ret = buildTreeWithLoc(termAddExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
		{: ret = buildTreeWithLoc(termAddExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| AddExpression minus MulExpression;
		{: ret = buildTreeWithLoc(termAddExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
CatExpression :=
	AddExpression tilde MulExpression;
		{: ret = buildTreeWithLoc(termCatExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
MulExpression :=
	UnaryExpression;
		{: ret = buildTreeWithLoc(termMulExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| MulExpression star UnaryExpression;
		{: ret = buildTreeWithLoc(termMulExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| MulExpression div UnaryExpression;
		{: ret = buildTreeWithLoc(termMulExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| MulExpression modulo UnaryExpression;
		{: ret = buildTreeWithLoc(termMulExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
PowExpression :=
	PostfixExpression;
		{: ret = buildTreeWithLoc(termPowExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| PostfixExpression xorxor UnaryExpression;
		{: ret = buildTreeWithLoc(termPowExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
UnaryExpression :=
	and UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| increment UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| decrement UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| star UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| minus UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| plus UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| bang UnaryExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ComplementExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lparen Type rparen dot identifier;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-4,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| NewExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| DeleteExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| CastExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| PowExpression;
		{: ret = buildTreeWithLoc(termUnaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ComplementExpression := 
	tilde UnaryExpression;
		{: ret = buildTreeWithLoc(termComplementExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
NewExpression := 
	new AllocatorArguments Type lbrack AssignExpression rbrack;
		{: ret = buildTreeWithLoc(termNewExpression, [-5,-4,-2], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new Type lbrack AssignExpression rbrack;
		{: ret = buildTreeWithLoc(termNewExpression, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| new AllocatorArguments Type lparen ArgumentList lparen;
		{: ret = buildTreeWithLoc(termNewExpression, [-5,-4,-2], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new Type lparen ArgumentList lparen;
		{: ret = buildTreeWithLoc(termNewExpression, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| new AllocatorArguments Type;
		{: ret = buildTreeWithLoc(termNewExpression, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| new Type;
		{: ret = buildTreeWithLoc(termNewExpression, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| NewAnonClassExpression;
		{: ret = buildTreeWithLoc(termNewExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
AllocatorArguments :=
	lparen ArgumentList rparen;
		{: ret = buildTreeWithLoc(termAllocatorArguments, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lparen rparen;
		{: ret = buildTreeWithLoc(termAllocatorArguments, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ArgumentList :=
	AssignExpression ;
		{: ret = buildTreeWithLoc(termArgumentList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssignExpression comma;
		{: ret = buildTreeWithLoc(termArgumentList, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| AssignExpression comma ArgumentList;
		{: ret = buildTreeWithLoc(termArgumentList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
DeleteExpression :=
	delete UnaryExpression;
		{: ret = buildTreeWithLoc(termDeleteExpression, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
CastExpression :=
	cast lparen Type rparen UnaryExpression;
		{: ret = buildTreeWithLoc(termCastExpression, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| cast lparen CastQual rparen UnaryExpression;
		{: ret = buildTreeWithLoc(termCastExpression, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| cast lparen rparen UnaryExpression;
		{: ret = buildTreeWithLoc(termCastExpression, [-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
CastQual :=
	const;
		{: ret = buildTreeWithLoc(termCastQual, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| const shared;
		{: ret = buildTreeWithLoc(termCastQual, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| shared const;
		{: ret = buildTreeWithLoc(termCastQual, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termCastQual, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout shared;
		{: ret = buildTreeWithLoc(termCastQual, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| shared inout;
		{: ret = buildTreeWithLoc(termCastQual, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termCastQual, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termCastQual, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// not clear if its an PostfixExpression of UnaryExpression
// Unary would make sense though it's need to new Objects
// NewExpression was missing
// checked
PostfixExpression :=
	PrimaryExpression;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| PostfixExpression dot identifier;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| PostfixExpression dot TemplateInstance;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| PostfixExpression dot NewExpression;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| PostfixExpression increment;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| PostfixExpression decrement;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| PostfixExpression lparen rparen;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| PostfixExpression lparen ArgumentList rparen;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| IndexExpression;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| SliceExpression;
		{: ret = buildTreeWithLoc(termPostfixExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
IndexExpression :=
	PostfixExpression lbrack ArgumentList rbrack;
		{: ret = buildTreeWithLoc(termIndexExpression, [-4,-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
SliceExpression :=
	PostfixExpression lbrack rbrack;
		{: ret = buildTreeWithLoc(termSliceExpression, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| PostfixExpression lbrack AssignExpression dotdot AssignExpression rbrack;
		{: ret = buildTreeWithLoc(termSliceExpression, [-6,-4,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
PrimaryExpression :=
	identifier;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dot identifier;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| TemplateInstance;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dot TemplateInstance;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| this;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| super;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| null;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| true;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| false;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dollarsym;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| file;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| line;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| integer;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| floatliteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| charliteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| stringliteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ArrayLiteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssocArrayLiteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Lambda;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| FunctionLiteral;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssertExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| MixinExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ImportExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| BasicType dot identifier;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| Typeof;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TypeidExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| IsExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lparen Expression rparen;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| TraitsExpression;
		{: ret = buildTreeWithLoc(termPrimaryExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ArrayLiteral :=
	lbrack ArgumentList rbrack;
		{: ret = buildTreeWithLoc(termArrayLiteral, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
AssocArrayLiteral :=
	lbrack KeyValuePairs rbrack;
		{: ret = buildTreeWithLoc(termAssocArrayLiteral, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
KeyValuePairs :=
	KeyValuePair;
		{: ret = buildTreeWithLoc(termKeyValuePairs, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| KeyValuePair comma KeyValuePairs;
		{: ret = buildTreeWithLoc(termKeyValuePairs, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
KeyValuePair :=
	KeyExpression colon ValueExpression;
		{: ret = buildTreeWithLoc(termKeyValuePair, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
KeyExpression :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termKeyExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ValueExpression :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termValueExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Lambda :=
	identifier arrow AssignExpression;
		{: ret = buildTreeWithLoc(termLambda, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| ParameterAttributes arrow AssignExpression;
		{: ret = buildTreeWithLoc(termLambda, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
FunctionLiteral :=
	function Type ParameterAttributes FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-4,-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| function ParameterAttributes FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| function Type FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| function FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| delegate Type ParameterAttributes FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-4,-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| delegate ParameterAttributes FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| delegate Type FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| delegate FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| ParameterAttributes FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| FunctionBody;
		{: ret = buildTreeWithLoc(termFunctionLiteral, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ParameterAttributes :=
	Parameters;
		{: ret = buildTreeWithLoc(termParameterAttributes, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Parameters FunctionAttributes;
		{: ret = buildTreeWithLoc(termParameterAttributes, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AssertExpression :=
	assert lparen AssignExpression rparen;
		{: ret = buildTreeWithLoc(termAssertExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| assert lparen AssignExpression comma AssignExpression rparen;
		{: ret = buildTreeWithLoc(termAssertExpression, [-4,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
MixinExpression :=
	mixin lparen AssignExpression rparen;
		{: ret = buildTreeWithLoc(termMixinExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
ImportExpression :=
	import lparen AssignExpression rparen;
		{: ret = buildTreeWithLoc(termImportExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
TypeidExpression :=
	typeid lparen Type rparen;
		{: ret = buildTreeWithLoc(termTypeidExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| typeid lparen Expression rparen;
		{: ret = buildTreeWithLoc(termTypeidExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
IsExpression :=
	is lparen Type rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| is lparen Type colon TypeSpecialization rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-4,-3,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| is lparen Type equal TypeSpecialization rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-4,-3,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| is lparen Type identifier rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-3,-2], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| is lparen Type identifier colon TypeSpecialization rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-5,-4,-3,-2], 
			actionNum, this.tokenStack[-7].getLoc()); :}
	| is lparen Type identifier equal TypeSpecialization rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-5,-4,-3,-2], 
			actionNum, this.tokenStack[-7].getLoc()); :}
	| is lparen Type identifier colon TypeSpecialization comma TemplateParameterList rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-6,-5,-4,-3,-2], 
			actionNum, this.tokenStack[-8].getLoc()); :}
	| is lparen Type identifier equal TypeSpecialization comma TemplateParameterList rparen;
		{: ret = buildTreeWithLoc(termIsExpression, [-6,-5,-4,-3,-2], 
			actionNum, this.tokenStack[-8].getLoc()); :}

// checked
TypeSpecialization :=
	Type;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| class;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| const;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| delegate;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| enum;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| function;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| immutable;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| inout;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| interface;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| return;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| shared;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| struct;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| super;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| union;
		{: ret = buildTreeWithLoc(termTypeSpecialization, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TraitsExpression :=
	traits lparen TraitsKeyword comma TraitsArguments rparen;
		{: ret = buildTreeWithLoc(termTraitsExpression, [-4,-2], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
TraitsKeyword :=
	identifier;
		{: ret = buildTreeWithLoc(termTraitsKeyword, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TraitsArguments :=
	TraitsArgument;
		{: ret = buildTreeWithLoc(termTraitsArguments, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TraitsArgument comma TraitsArguments;
		{: ret = buildTreeWithLoc(termTraitsArguments, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
TraitsArgument :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termTraitsArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Type;
		{: ret = buildTreeWithLoc(termTraitsArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Statement :=
    semicolon;
		{: ret = buildTreeWithLoc(termStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | NonEmptyStatement;
		{: ret = buildTreeWithLoc(termStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ScopeBlockStatement;
		{: ret = buildTreeWithLoc(termStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NoScopeNonEmptyStatement :=
    NonEmptyStatement;
		{: ret = buildTreeWithLoc(termNoScopeNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | BlockStatement;
		{: ret = buildTreeWithLoc(termNoScopeNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NoScopeStatement :=
    semicolon;
		{: ret = buildTreeWithLoc(termNoScopeStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | NonEmptyStatement;
		{: ret = buildTreeWithLoc(termNoScopeStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | BlockStatement;
		{: ret = buildTreeWithLoc(termNoScopeStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NonEmptyOrScopeBlockStatement :=
    NonEmptyStatement;
		{: ret = buildTreeWithLoc(termNonEmptyOrScopeBlockStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ScopeBlockStatement;
		{: ret = buildTreeWithLoc(termNonEmptyOrScopeBlockStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NonEmptyStatement :=
    NonEmptyStatementNoCaseNoDefault;
		{: ret = buildTreeWithLoc(termNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | CaseStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | CaseRangeStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | DefaultStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
NonEmptyStatementNoCaseNoDefault :=
    LabeledStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ExpressionStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | DeclarationStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | IfStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | WhileStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | DoStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ForStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ForeachStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | SwitchStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | FinalSwitchStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ContinueStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | BreakStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ReturnStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | GotoStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | WithStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | SynchronizedStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | TryStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ScopeGuardStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ThrowStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | AsmStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | PragmaStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | MixinStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ForeachRangeStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ConditionalStatement;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | StaticAssert;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | TemplateMixin;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ImportDeclaration;
		{: ret = buildTreeWithLoc(termNonEmptyStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ScopeStatement :=
    NonEmptyStatement;
		{: ret = buildTreeWithLoc(termScopeStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | BlockStatement;
		{: ret = buildTreeWithLoc(termScopeStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ScopeBlockStatement :=
    BlockStatement;
		{: ret = buildTreeWithLoc(termScopeBlockStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
LabeledStatement :=
	identifier colon NoScopeStatement;
		{: ret = buildTreeWithLoc(termLabeledStatement, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
BlockStatement :=
	lcurly rcurly ;
		{: ret = buildTreeWithLoc(termBlockStatement, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| lcurly StatementList rcurly;
		{: ret = buildTreeWithLoc(termBlockStatement, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
StatementList :=
	Statement;
		{: ret = buildTreeWithLoc(termStatementList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Statement StatementList;
		{: ret = buildTreeWithLoc(termStatementList, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ExpressionStatement :=
	Expression semicolon;
		{: ret = buildTreeWithLoc(termExpressionStatement, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
DeclarationStatement :=
	Declaration;
		{: ret = buildTreeWithLoc(termDeclarationStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
IfStatement :=
	if lparen IfCondition rparen ThenStatement;
		{: ret = buildTreeWithLoc(termIfStatement, [-4,-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| if lparen IfCondition rparen ThenStatement else ElseStatement;
		{: ret = buildTreeWithLoc(termIfStatement, [-5,-3,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}

// checked
IfCondition :=
	Expression;
		{: ret = buildTreeWithLoc(termIfCondition, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| auto identifier assign Expression;
		{: ret = buildTreeWithLoc(termIfCondition, [-4,-3,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| BasicType Declarator assign Expression;
		{: ret = buildTreeWithLoc(termIfCondition, [-4,-3,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
ThenStatement :=
	ScopeStatement;
		{: ret = buildTreeWithLoc(termThenStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ElseStatement :=
	ScopeStatement;
		{: ret = buildTreeWithLoc(termElseStatement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
WhileStatement :=
	while lparen Expression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termWhileStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
DoStatement :=
	do ScopeStatement while lparen Expression rparen semicolon;
		{: ret = buildTreeWithLoc(termDoStatement, [-6,-3], 
			actionNum, this.tokenStack[-7].getLoc()); :}

// checked
ForStatement :=
    for lparen Initialize Test semicolon Increment rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termForStatement, [-6,-5,-3,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
    | for lparen Initialize Test semicolon rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termForStatement, [-5,-4,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
    | for lparen Initialize semicolon Increment rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termForStatement, [-5,-3,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
    | for lparen Initialize semicolon rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termForStatement, [-4,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
Initialize :=
	semicolon;
		{: ret = buildTreeWithLoc(termInitialize, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termInitialize, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// expression was opt
// checked
Test :=
	Expression;
		{: ret = buildTreeWithLoc(termTest, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// expression was opt
// checked
Increment :=
	Expression;
		{: ret = buildTreeWithLoc(termIncrement, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ForeachStatement :=
	Foreach lparen ForeachTypeList semicolon Aggregate rparen NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termForeachStatement, [-5,-3,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}

// checked
Foreach :=
	foreach;
		{: ret = buildTreeWithLoc(termForeach, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| foreach_reverse;
		{: ret = buildTreeWithLoc(termForeach, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ForeachTypeList :=
	ForeachType;
		{: ret = buildTreeWithLoc(termForeachTypeList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ForeachType comma ForeachTypeList;
		{: ret = buildTreeWithLoc(termForeachTypeList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ForeachType :=
	ref BasicType Declarator;
		{: ret = buildTreeWithLoc(termForeachType, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| ref identifier;
		{: ret = buildTreeWithLoc(termForeachType, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| BasicType identifier;
		{: ret = buildTreeWithLoc(termForeachType, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| identifier;
		{: ret = buildTreeWithLoc(termForeachType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Aggregate :=
	Expression;
		{: ret = buildTreeWithLoc(termAggregate, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
SwitchStatement :=
	switch lparen Expression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termSwitchStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
CaseStatement :=
	case ArgumentList colon ScopeStatementList;
		{: ret = buildTreeWithLoc(termCaseStatement, [-3,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
CaseRangeStatement :=
	case FirstExp colon dotdot case LastExp colon ScopeStatementList;
		{: ret = buildTreeWithLoc(termCaseRangeStatement, [-7,-3,-1], 
			actionNum, this.tokenStack[-8].getLoc()); :}

// checked
FirstExp :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termFirstExp, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
LastExp :=
	AssignExpression;
		{: ret = buildTreeWithLoc(termLastExp, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
DefaultStatement :=
	default colon ScopeStatementList;
		{: ret = buildTreeWithLoc(termDefaultStatement, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ScopeStatementList :=
    StatementListNoCaseNoDefault;
		{: ret = buildTreeWithLoc(termScopeStatementList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
StatementListNoCaseNoDefault :=
    StatementNoCaseNoDefault;
		{: ret = buildTreeWithLoc(termStatementListNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | StatementNoCaseNoDefault StatementListNoCaseNoDefault;
		{: ret = buildTreeWithLoc(termStatementListNoCaseNoDefault, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
StatementNoCaseNoDefault :=
    semicolon;
		{: ret = buildTreeWithLoc(termStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | NonEmptyStatementNoCaseNoDefault;
		{: ret = buildTreeWithLoc(termStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
    | ScopeBlockStatement;
		{: ret = buildTreeWithLoc(termStatementNoCaseNoDefault, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
FinalSwitchStatement :=
	final switch lparen Expression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termFinalSwitchStatement, [-3,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
ContinueStatement :=
	continue semicolon;
		{: ret = buildTreeWithLoc(termContinueStatement, [-2], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| continue identifier semicolon;
		{: ret = buildTreeWithLoc(termContinueStatement, [-3,-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
BreakStatement :=
	break semicolon;
		{: ret = buildTreeWithLoc(termBreakStatement, [-2], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| break identifier semicolon;
		{: ret = buildTreeWithLoc(termBreakStatement, [-3,-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ReturnStatement :=
	return semicolon;
		{: ret = buildTreeWithLoc(termReturnStatement, [-2], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| return Expression semicolon;
		{: ret = buildTreeWithLoc(termReturnStatement, [-3,-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
GotoStatement :=
	goto identifier semicolon;
		{: ret = buildTreeWithLoc(termGotoStatement, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| goto default semicolon;
		{: ret = buildTreeWithLoc(termGotoStatement, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| goto case semicolon;
		{: ret = buildTreeWithLoc(termGotoStatement, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| goto case Expression semicolon;
		{: ret = buildTreeWithLoc(termGotoStatement, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
WithStatement :=
	with lparen Expression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termWithStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| with lparen Symbol rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termWithStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| with lparen TemplateInstance rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termWithStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
SynchronizedStatement :=
	synchronized ScopeStatement;
		{: ret = buildTreeWithLoc(termSynchronizedStatement, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| synchronized lparen Expression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termSynchronizedStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
TryStatement :=
	try ScopeStatement Catches;
		{: ret = buildTreeWithLoc(termTryStatement, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| try ScopeStatement Catches FinallyStatement;
		{: ret = buildTreeWithLoc(termTryStatement, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| try ScopeStatement FinallyStatement;
		{: ret = buildTreeWithLoc(termTryStatement, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
Catches :=
	LastCatch;
		{: ret = buildTreeWithLoc(termCatches, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Catch;
		{: ret = buildTreeWithLoc(termCatches, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Catch Catches;
		{: ret = buildTreeWithLoc(termCatches, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
LastCatch :=
	catch NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termLastCatch, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
Catch :=
	catch lparen CatchParameter rparen NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termCatch, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
CatchParameter :=
	BasicType identifier;
		{: ret = buildTreeWithLoc(termCatchParameter, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
FinallyStatement :=
	finally NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termFinallyStatement, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ThrowStatement :=
	throw Expression semicolon;
		{: ret = buildTreeWithLoc(termThrowStatement, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ScopeGuardStatement :=
	scope lparen exit rparen NonEmptyOrScopeBlockStatement;
		{: ret = buildTreeWithLoc(termScopeGuardStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| scope lparen success rparen NonEmptyOrScopeBlockStatement;
		{: ret = buildTreeWithLoc(termScopeGuardStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| scope lparen failure rparen NonEmptyOrScopeBlockStatement;
		{: ret = buildTreeWithLoc(termScopeGuardStatement, [-3,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
AsmStatement :=
	asm lcurly rcurly;
		{: ret = buildTreeWithLoc(termAsmStatement, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| asm lcurly AsmInstructionList rcurly;
		{: ret = buildTreeWithLoc(termAsmStatement, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
AsmInstructionList :=
	AsmInstruction semicolon;
		{: ret = buildTreeWithLoc(termAsmInstructionList, [-2], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| AsmInstruction semicolon AsmInstructionList;
		{: ret = buildTreeWithLoc(termAsmInstructionList, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
PragmaStatement :=
	Pragma NoScopeStatement;
		{: ret = buildTreeWithLoc(termPragmaStatement, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
MixinStatement :=
	mixin lparen AssignExpression rparen semicolon;
		{: ret = buildTreeWithLoc(termMixinStatement, [-3], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
ForeachRangeStatement :=
	Foreach lparen ForeachType semicolon LwrExpression dotdot UprExpression rparen ScopeStatement;
		{: ret = buildTreeWithLoc(termForeachRangeStatement, [-7,-5,-3,-1], 
			actionNum, this.tokenStack[-9].getLoc()); :}

// checked
LwrExpression :=
	Expression;
		{: ret = buildTreeWithLoc(termLwrExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
UprExpression :=
	Expression;
		{: ret = buildTreeWithLoc(termUprExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
AggregateDeclaration :=
	struct identifier StructBody;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| union identifier StructBody;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| struct identifier semicolon;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| union identifier semicolon;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| StructTemplateDeclaration;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| UnionTemplateDeclaration;
		{: ret = buildTreeWithLoc(termAggregateDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
StructBody :=
	lcurly StructBodyDeclarations rcurly;
		{: ret = buildTreeWithLoc(termStructBody, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lcurly rcurly;
		{: ret = buildTreeWithLoc(termStructBody, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
StructBodyDeclarations :=
	StructBodyDeclaration;
		{: ret = buildTreeWithLoc(termStructBodyDeclarations, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructBodyDeclaration StructBodyDeclarations;
		{: ret = buildTreeWithLoc(termStructBodyDeclarations, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
StructBodyDeclaration :=
	DeclDef;
		{: ret = buildTreeWithLoc(termStructBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructAllocator;
		{: ret = buildTreeWithLoc(termStructBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructDeallocator;
		{: ret = buildTreeWithLoc(termStructBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| StructPostblit;
		{: ret = buildTreeWithLoc(termStructBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AliasThis;
		{: ret = buildTreeWithLoc(termStructBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	
// checked
StructAllocator := 
	ClassAllocator;
		{: ret = buildTreeWithLoc(termStructAllocator, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked	
StructDeallocator :=
	ClassDeallocator;
		{: ret = buildTreeWithLoc(termStructDeallocator, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
StructPostblit :=
	this lparen this rparen FunctionBody;
		{: ret = buildTreeWithLoc(termStructPostblit, [-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
ClassDeclaration :=
	class identifier BaseClassList ClassBody;
		{: ret = buildTreeWithLoc(termClassDeclaration, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| class identifier ClassBody;
		{: ret = buildTreeWithLoc(termClassDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| ClassTemplateDeclaration;
		{: ret = buildTreeWithLoc(termClassDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
BaseClassList :=
	colon SuperClass;
		{: ret = buildTreeWithLoc(termBaseClassList, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| colon SuperClass comma Interfaces;
		{: ret = buildTreeWithLoc(termBaseClassList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| Interfaces;
		{: ret = buildTreeWithLoc(termBaseClassList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
SuperClass :=
	identifier;
		{: ret = buildTreeWithLoc(termSuperClass, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Interfaces :=
	Interface;
		{: ret = buildTreeWithLoc(termInterfaces, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Interface comma Interfaces;
		{: ret = buildTreeWithLoc(termInterfaces, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
Interface :=
	identifier;
		{: ret = buildTreeWithLoc(termInterface, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
ClassBody :=
	lcurly rcurly;
		{: ret = buildTreeWithLoc(termClassBody, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| lcurly ClassBodyDeclarations rcurly;
		{: ret = buildTreeWithLoc(termClassBody, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ClassBodyDeclarations :=
	ClassBodyDeclaration;
		{: ret = buildTreeWithLoc(termClassBodyDeclarations, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ClassBodyDeclaration ClassBodyDeclarations;
		{: ret = buildTreeWithLoc(termClassBodyDeclarations, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ClassBodyDeclaration :=
	DeclDef;
		{: ret = buildTreeWithLoc(termClassBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Invariant;
		{: ret = buildTreeWithLoc(termClassBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ClassAllocator;
		{: ret = buildTreeWithLoc(termClassBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| ClassDeallocator;
		{: ret = buildTreeWithLoc(termClassBodyDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Constructor :=
	this Parameters FunctionBody;
		{: ret = buildTreeWithLoc(termConstructor, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| TemplatedConstructor;
		{: ret = buildTreeWithLoc(termConstructor, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TemplatedConstructor :=
    this lparen TemplateParameterList rparen Parameters Constraint FunctionBody;
		{: ret = buildTreeWithLoc(termTemplatedConstructor, [-5,-3,-2,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
    | this lparen TemplateParameterList rparen Parameters FunctionBody;
		{: ret = buildTreeWithLoc(termTemplatedConstructor, [-4,-2,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
Destructor :=
	tilde this lparen rparen FunctionBody;
		{: ret = buildTreeWithLoc(termDestructor, [-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
StaticConstructor :=
	static this lparen rparen FunctionBody;
		{: ret = buildTreeWithLoc(termStaticConstructor, [-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
StaticDestructor :=
	static tilde this lparen rparen FunctionBody;
		{: ret = buildTreeWithLoc(termStaticDestructor, [-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
SharedStaticConstructor :=
	shared static this lparen rparen FunctionBody;
		{: ret = buildTreeWithLoc(termSharedStaticConstructor, [-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
SharedStaticDestructor :=
	shared static tilde this lparen rparen FunctionBody;
		{: ret = buildTreeWithLoc(termSharedStaticDestructor, [-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}

// checked
Invariant :=
	invariant lparen rparen BlockStatement;
		{: ret = buildTreeWithLoc(termInvariant, [-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
ClassAllocator :=
	new Parameters FunctionBody;
		{: ret = buildTreeWithLoc(termClassAllocator, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
ClassDeallocator :=
	delete Parameters FunctionBody;
		{: ret = buildTreeWithLoc(termClassDeallocator, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
AliasThis :=
	alias identifier this semicolon;
		{: ret = buildTreeWithLoc(termAliasThis, [-3], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
NewAnonClassExpression :=
	new AllocatorArguments class ClassArguments Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-5,-3,-2,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| new AllocatorArguments class ClassArguments SuperClass ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-5,-3,-2,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| new AllocatorArguments class ClassArguments SuperClass Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, 
			[-6,-4,-3,-2,-1], actionNum, this.tokenStack[-7].getLoc()); :}
	| new AllocatorArguments class Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-4,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new AllocatorArguments class SuperClass ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-4,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new AllocatorArguments class SuperClass Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-5,-3,-2,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| new class ClassArguments Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-3,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new class ClassArguments SuperClass ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-3,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| new class ClassArguments SuperClass Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-4,-3,-2,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	| new class ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| new class SuperClass Interfaces ClassBody;
		{: ret = buildTreeWithLoc(termNewAnonClassExpression, [-3,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
ClassArguments :=
	lparen ArgumentList rparen;
		{: ret = buildTreeWithLoc(termClassArguments, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lparen rparen;
		{: ret = buildTreeWithLoc(termClassArguments, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
InterfaceDeclaration :=
	interface identifier BaseInterfaceList InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceDeclaration, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| interface identifier InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| InterfaceTemplateDeclaration;
		{: ret = buildTreeWithLoc(termInterfaceDeclaration, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked, need to check if InterfaceClasses are BaseClassList
BaseInterfaceList :=
	colon BaseClassList;
		{: ret = buildTreeWithLoc(termBaseInterfaceList, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
InterfaceBody :=
	lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termInterfaceBody, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lcurly rcurly;
		{: ret = buildTreeWithLoc(termInterfaceBody, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
EnumDeclaration := enum EnumBody; 
		{: ret = buildTreeWithLoc(termEnumDeclaration, [-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| enum EnumTag EnumBody;
		{: ret = buildTreeWithLoc(termEnumDeclaration, [-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	| enum EnumTag colon EnumBaseType EnumBody;
		{: ret = buildTreeWithLoc(termEnumDeclaration, [-4,-2,-1], actionNum, 
			this.tokenStack[-5].getLoc()); :}
	| enum colon EnumBaseType EnumBody;
		{: ret = buildTreeWithLoc(termEnumDeclaration, [-2,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}

// checked
EnumTag :=
	identifier; 
		{: ret = buildTreeWithLoc(termEnumTag, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
EnumBaseType :=
	Type;
		{: ret = buildTreeWithLoc(termEnumBaseType, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
EnumBody :=
	semicolon;
		{: ret = buildTreeWithLoc(termEnumBody, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lcurly EnumMembers rcurly; 
		{: ret = buildTreeWithLoc(termEnumBody, [-2], actionNum, 
			this.tokenStack[-3].getLoc()); :}

// checked
EnumMembers :=
	EnumMember;
		{: ret = buildTreeWithLoc(termEnumMembers, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| EnumMembers comma; 
		{: ret = buildTreeWithLoc(termEnumMembers, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	| EnumMembers comma EnumMember; 
		{: ret = buildTreeWithLoc(termEnumMembers, [-3,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}

// checked
EnumMember :=
	 identifier;
		{: ret = buildTreeWithLoc(termEnumMember, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | identifier assign AssignExpression; 
		{: ret = buildTreeWithLoc(termEnumMember, [-3,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	 | Type assign AssignExpression;
		{: ret = buildTreeWithLoc(termEnumMember, [-3,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}

// checked
FunctionBody :=
	 BlockStatement ;
		{: ret = buildTreeWithLoc(termFunctionBody, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | BodyStatement;
		{: ret = buildTreeWithLoc(termFunctionBody, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | InStatement BodyStatement;
		{: ret = buildTreeWithLoc(termFunctionBody, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	 | OutStatement BodyStatement;
		{: ret = buildTreeWithLoc(termFunctionBody, [-2,-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	 | InStatement OutStatement BodyStatement;
		{: ret = buildTreeWithLoc(termFunctionBody, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}
	 | OutStatement InStatement BodyStatement;
		{: ret = buildTreeWithLoc(termFunctionBody, [-3,-2,-1], actionNum, 
			this.tokenStack[-3].getLoc()); :}

// checked
InStatement :=
	 in BlockStatement;
		{: ret = buildTreeWithLoc(termInStatement, [-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
OutStatement :=
	 out BlockStatement;
		{: ret = buildTreeWithLoc(termOutStatement, [-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}
	 | out lparen identifier rparen BlockStatement;
		{: ret = buildTreeWithLoc(termOutStatement, [-3,-1], actionNum, 
			this.tokenStack[-4].getLoc()); :}

// checked
BodyStatement :=
	 body BlockStatement;
		{: ret = buildTreeWithLoc(termBodyStatement, [-1], actionNum, 
			this.tokenStack[-2].getLoc()); :}

// checked
ConditionalDeclaration :=
	 Condition CCDeclarationBlock;
		{: ret = buildTreeWithLoc(termConditionalDeclaration, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	 | Condition CCDeclarationBlock else CCDeclarationBlock;
		{: ret = buildTreeWithLoc(termConditionalDeclaration, [-4,-3,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | Condition colon Declarations;
		{: ret = buildTreeWithLoc(termConditionalDeclaration, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
CCDeclarationBlock :=
	Declaration;
		{: ret = buildTreeWithLoc(termCCDeclarationBlock, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| lcurly Declarations rcurly;
		{: ret = buildTreeWithLoc(termCCDeclarationBlock, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| lcurly rcurly;
		{: ret = buildTreeWithLoc(termCCDeclarationBlock, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
Declarations :=
	Declaration;
		{: ret = buildTreeWithLoc(termDeclarations, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Declaration Declarations;
		{: ret = buildTreeWithLoc(termDeclarations, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ConditionalStatement :=
	 Condition NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termConditionalStatement, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	 | Condition NoScopeNonEmptyStatement else NoScopeNonEmptyStatement;
		{: ret = buildTreeWithLoc(termConditionalStatement, [-4,-3,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
Condition :=
	 VersionCondition;
		{: ret = buildTreeWithLoc(termCondition, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | DebugCondition;
		{: ret = buildTreeWithLoc(termCondition, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | StaticIfCondition;
		{: ret = buildTreeWithLoc(termCondition, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
VersionCondition :=
	 version lparen integer rparen;
		{: ret = buildTreeWithLoc(termVersionCondition, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | version lparen identifier rparen;
		{: ret = buildTreeWithLoc(termVersionCondition, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | version lparen unittest rparen;
		{: ret = buildTreeWithLoc(termVersionCondition, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
VersionSpecification :=
	 version assign identifier semicolon;
		{: ret = buildTreeWithLoc(termVersionSpecification, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | version assign integer semicolon;
		{: ret = buildTreeWithLoc(termVersionSpecification, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
DebugCondition :=
	 debug;
		{: ret = buildTreeWithLoc(termDebugCondition, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	 | debug lparen integer rparen;
		{: ret = buildTreeWithLoc(termDebugCondition, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | debug lparen identifier rparen;
		{: ret = buildTreeWithLoc(termDebugCondition, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
DebugSpecification :=
	 debug assign identifier semicolon;
		{: ret = buildTreeWithLoc(termDebugSpecification, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	 | debug assign integer semicolon;
		{: ret = buildTreeWithLoc(termDebugSpecification, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
StaticIfCondition :=
	 static if lparen AssignExpression rparen;
		{: ret = buildTreeWithLoc(termStaticIfCondition, [-2], 
			actionNum, this.tokenStack[-5].getLoc()); :}

// checked
StaticAssert :=
	 static assert lparen AssignExpression rparen semicolon;
		{: ret = buildTreeWithLoc(termStaticAssert, [-3], 
			actionNum, this.tokenStack[-6].getLoc()); :}
	 | static assert lparen AssignExpression comma AssignExpression rparen semicolon;
		{: ret = buildTreeWithLoc(termStaticAssert, [-5,-3], 
			actionNum, this.tokenStack[-8].getLoc()); :}

// checked
TemplateDeclaration :=
	template TemplateIdentifier lparen TemplateParameterList rparen Constraint lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termTemplateDeclaration, [-8,-6,-4,-2], 
			actionNum, this.tokenStack[-9].getLoc()); :}
	| template TemplateIdentifier lparen TemplateParameterList rparen lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termTemplateDeclaration, [-7,-5,-2], 
			actionNum, this.tokenStack[-8].getLoc()); :}

// checked
TemplateIdentifier :=
	identifier;
		{: ret = buildTreeWithLoc(termTemplateIdentifier, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TemplateParameterList :=
	TemplateParameter;
		{: ret = buildTreeWithLoc(termTemplateParameterList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateParameter comma;
		{: ret = buildTreeWithLoc(termTemplateParameterList, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| TemplateParameter comma TemplateParameterList;
		{: ret = buildTreeWithLoc(termTemplateParameterList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateParameter :=
	TemplateTypeParameter;
		{: ret = buildTreeWithLoc(termTemplateParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateValueParameter;
		{: ret = buildTreeWithLoc(termTemplateParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateAliasParameter;
		{: ret = buildTreeWithLoc(termTemplateParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateTupleParameter;
		{: ret = buildTreeWithLoc(termTemplateParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateThisParameter;
		{: ret = buildTreeWithLoc(termTemplateParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TemplateTupleParameter :=
	identifier dotdotdot;
		{: ret = buildTreeWithLoc(termTemplateTupleParameter, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

//IdentifierOrTemplateInstance :=
//	identifier;
//	| TemplateInstance;

// checked
TemplateInstance :=
	TemplateIdentifier bang lparen TemplateArgumentList rparen;
		{: ret = buildTreeWithLoc(termTemplateInstance, [-5,-2], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| TemplateIdentifier bang TemplateSingleArgument;
		{: ret = buildTreeWithLoc(termTemplateInstance, [-3,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
TemplateThisParameter :=
    this TemplateTypeParameter;
		{: ret = buildTreeWithLoc(termTemplateThisParameter, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateArgumentList :=
	TemplateArgument;
		{: ret = buildTreeWithLoc(termTemplateArgumentList, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateArgument comma;
		{: ret = buildTreeWithLoc(termTemplateArgumentList, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| TemplateArgument comma TemplateArgumentList;
		{: ret = buildTreeWithLoc(termTemplateArgumentList, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateArgument :=
	Type;
		{: ret = buildTreeWithLoc(termTemplateArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| AssignExpression;
		{: ret = buildTreeWithLoc(termTemplateArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| Symbol;
		{: ret = buildTreeWithLoc(termTemplateArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
Symbol :=
	SymbolTail;
		{: ret = buildTreeWithLoc(termSymbol, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| dot SymbolTail;
		{: ret = buildTreeWithLoc(termSymbol, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
SymbolTail :=
	identifier;
		{: ret = buildTreeWithLoc(termSymbolTail, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier dot SymbolTail;
		{: ret = buildTreeWithLoc(termSymbolTail, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| TemplateInstance;
		{: ret = buildTreeWithLoc(termSymbolTail, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| TemplateInstance dot SymbolTail;
		{: ret = buildTreeWithLoc(termSymbolTail, [-3,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateSingleArgument :=
	identifier;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| BasicTypeX;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| charliteral;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| stringliteral;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| integer;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| floatliteral;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| true;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| false;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| null;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| file;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| line;
		{: ret = buildTreeWithLoc(termTemplateSingleArgument, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TemplateTypeParameter :=
	identifier;
		{: ret = buildTreeWithLoc(termTemplateTypeParameter, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}
	| identifier TemplateTypeParameterSpecialization;
		{: ret = buildTreeWithLoc(termTemplateTypeParameter, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| identifier TemplateTypeParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateTypeParameter, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| identifier TemplateTypeParameterSpecialization TemplateTypeParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateTypeParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
TemplateTypeParameterSpecialization :=
	colon Type;
		{: ret = buildTreeWithLoc(termTemplateTypeParameterSpecialization, 
			[-2,-1], actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateTypeParameterDefault :=
	assign Type;
		{: ret = buildTreeWithLoc(termTemplateTypeParameterDefault, 
			[-2,-1], actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateValueParameter :=
    BasicType Declarator;
		{: ret = buildTreeWithLoc(termTemplateValueParameter, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
    | BasicType Declarator TemplateValueParameterSpecialization;
		{: ret = buildTreeWithLoc(termTemplateValueParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
    | BasicType Declarator TemplateValueParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateValueParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
    | BasicType Declarator TemplateValueParameterSpecialization TemplateValueParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateValueParameter, [-4,-3,-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
TemplateValueParameterSpecialization :=
    colon ConditionalExpression;
		{: ret = buildTreeWithLoc(termTemplateValueParameterSpecialization, 
			[-2,-1], actionNum, this.tokenStack[-2].getLoc()); :}

// already part of conditionalexpression
// checked
TemplateValueParameterDefault :=
	assign file;
		{: ret = buildTreeWithLoc(termTemplateValueParameterDefault, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| assign line;
		{: ret = buildTreeWithLoc(termTemplateValueParameterDefault, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| assign AssignExpression;
		{: ret = buildTreeWithLoc(termTemplateValueParameterDefault, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateAliasParameter :=
	alias BasicType Declarator TemplateAliasParameterSpecialization TemplateAliasParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-4,-3,-2,-1], 
			actionNum, this.tokenStack[-5].getLoc()); :}
	| alias identifier TemplateAliasParameterSpecialization TemplateAliasParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| alias identifier TemplateAliasParameterSpecialization;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| alias identifier TemplateAliasParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| alias identifier;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| alias BasicType Declarator TemplateAliasParameterDefault;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| alias BasicType Declarator TemplateAliasParameterSpecialization;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-3,-2,-1], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| alias BasicType Declarator;
		{: ret = buildTreeWithLoc(termTemplateAliasParameter, [-2,-1], 
			actionNum, this.tokenStack[-3].getLoc()); :}

// checked
TemplateAliasParameterSpecialization :=
	colon Type;
		{: ret = buildTreeWithLoc(termTemplateAliasParameterSpecialization, 
			[-1] , actionNum, this.tokenStack[-2].getLoc()); :}
	| colon ConditionalExpression;
		{: ret = buildTreeWithLoc(termTemplateAliasParameterSpecialization, 
			[-1] , actionNum, this.tokenStack[-2].getLoc()); :}

// checked
TemplateAliasParameterDefault :=
	assign Type;
		{: ret = buildTreeWithLoc(termTemplateAliasParameterDefault, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}
	| assign ConditionalExpression;
		{: ret = buildTreeWithLoc(termTemplateAliasParameterDefault, [-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
ClassTemplateDeclaration :=
	class identifier lparen TemplateParameterList rparen Constraint BaseClassList ClassBody;
		{: ret = buildTreeWithLoc(termClassTemplateDeclaration, 
			[-7,-5,-3,-2,-1], actionNum, this.tokenStack[-8].getLoc()); :}
	| class identifier lparen TemplateParameterList rparen BaseClassList ClassBody;
		{: ret = buildTreeWithLoc(termClassTemplateDeclaration, [-6,-4,-2,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
	| class identifier lparen TemplateParameterList rparen Constraint ClassBody;
		{: ret = buildTreeWithLoc(termClassTemplateDeclaration, [-6,-4,-2,-1], 
			actionNum, this.tokenStack[-7].getLoc()); :}
	| class identifier lparen TemplateParameterList rparen ClassBody;
		{: ret = buildTreeWithLoc(termClassTemplateDeclaration, [-5,-3,-1], 
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
StructTemplateDeclaration :=
	struct identifier lparen TemplateParameterList rparen Constraint StructBody;
		{: ret = buildTreeWithLoc(termStructTemplateDeclaration, [-6,-4,-2,-1],
			actionNum, this.tokenStack[-7].getLoc()); :}
	| struct identifier lparen TemplateParameterList rparen StructBody;
		{: ret = buildTreeWithLoc(termStructTemplateDeclaration, [-5,-3,-1],
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
UnionTemplateDeclaration :=
	union identifier lparen TemplateParameterList rparen Constraint StructBody;
		{: ret = buildTreeWithLoc(termUnionTemplateDeclaration, [-6,-4,-2,-1],
			actionNum, this.tokenStack[-7].getLoc()); :}
	| union identifier lparen TemplateParameterList rparen StructBody;
		{: ret = buildTreeWithLoc(termUnionTemplateDeclaration, [-5,-3,-1],
			actionNum, this.tokenStack[-6].getLoc()); :}

// checked
InterfaceTemplateDeclaration :=
	interface identifier lparen TemplateParameterList rparen Constraint BaseInterfaceList InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceTemplateDeclaration, 
			[-7,-5,-3,-2,-1], actionNum, this.tokenStack[-8].getLoc()); :}
	| interface identifier lparen TemplateParameterList rparen Constraint InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceTemplateDeclaration, 
			[-6,-4,-2,-1], actionNum, this.tokenStack[-7].getLoc()); :}
	| interface identifier lparen TemplateParameterList rparen InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceTemplateDeclaration, 
			[-5,-3,-1], actionNum, this.tokenStack[-6].getLoc()); :}
	| interface identifier lparen TemplateParameterList rparen BaseInterfaceList InterfaceBody;
		{: ret = buildTreeWithLoc(termInterfaceTemplateDeclaration, 
			[-6,-4,-2,-1], actionNum, this.tokenStack[-7].getLoc()); :}

// checked
TemplateMixinDeclaration :=
	mixin template TemplateIdentifier lparen TemplateParameterList rparen Constraint lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termTemplateMixinDeclaration,
			[-8,-6,-4,-2], actionNum, this.tokenStack[-10].getLoc()); :}
	| mixin template TemplateIdentifier lparen TemplateParameterList rparen lcurly DeclDefs rcurly;
		{: ret = buildTreeWithLoc(termTemplateMixinDeclaration, 
			[-7,-5,-2], actionNum, this.tokenStack[-9].getLoc()); :}

// checked
Constraint :=
	if lparen ConstraintExpression rparen;
		{: ret = buildTreeWithLoc(termConstraint, [-2], 
			actionNum, this.tokenStack[-4].getLoc()); :}

// checked
ConstraintExpression :=
	Expression;
		{: ret = buildTreeWithLoc(termConstraintExpression, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}

// checked
TemplateMixin :=
	mixin TemplateIdentifier semicolon;
		{: ret = buildTreeWithLoc(termTemplateMixin, [-2], 
			actionNum, this.tokenStack[-3].getLoc()); :}
	| mixin TemplateIdentifier identifier semicolon;
		{: ret = buildTreeWithLoc(termTemplateMixin, [-3], 
			actionNum, this.tokenStack[-4].getLoc()); :}
	| mixin TemplateIdentifier bang lparen TemplateArgumentList rparen semicolon;
		{: ret = buildTreeWithLoc(termTemplateMixin, [-6,-3], 
			actionNum, this.tokenStack[-7].getLoc()); :}
	| mixin TemplateIdentifier bang lparen TemplateArgumentList rparen semicolon identifier;
		{: ret = buildTreeWithLoc(termTemplateMixin, [-7,-4,-1], 
			actionNum, this.tokenStack[-8].getLoc()); :}

// checked
UnitTest :=
	unittest FunctionBody;
		{: ret = buildTreeWithLoc(termUnitTest, [-2,-1], 
			actionNum, this.tokenStack[-2].getLoc()); :}

// checked
AsmInstruction :=
	stringliteral;
		{: ret = buildTreeWithLoc(termAsmInstruction, [-1], 
			actionNum, this.tokenStack[-1].getLoc()); :}