seatdModule:
     ModuleDeclarationOpt DeclDefsOpt

ModuleDeclarationOpt:
     ModuleKeyword ModuleName ;
     epsilon

ModuleKeyword:
     module

ModuleName:
     ModuleName \. Identifier
     Identifier

DeclDefsOpt:
     DeclDefsOpt DeclDef
     epsilon

DeclDef:
     ConditionalDeclaration
     DeclDefNoConditional

DeclDefNoConditional:
     AttributeSpecifier
     StaticAssert
     Declaration
     ImportDeclaration
     EnumDeclaration
     TemplateMixin
     TemplateDeclaration
     FunctionTemplateDeclaration
     ClassTemplateDeclaration
     InterfaceTemplateDeclaration
     StructTemplateDeclaration
     ClassDeclaration
     InterfaceDeclaration
     AggregateDeclaration
     Constructor
     Destructor
     Invariant
     UnitTest
     StaticConstructor
     StaticDestructor
     MixinDeclaration
     ;
     DebugSpecification
     VersionSpecification

ConditionalDeclaration:
     Condition :
     Condition DeclarationBlock
     Condition DeclarationBlock else DeclarationBlock

Condition:
     VersionCondition
     DebugCondition
     StaticIfCondition

VersionCondition:
     version \( Integer \)
     version \( Identifier \)

VersionSpecification:
     version = Integer ;
     version = Identifier ;

DebugCondition:
     debug \( Integer \)
     debug \( Identifier \)
     debug

DebugSpecification:
     debug = Identifier ;
     debug = Integer ;

StaticIfCondition:
     static if \( AssignExpression \)

StaticAssert:
     static assert \( AssignExpression , AssignExpression \) ;
     static assert \( AssignExpression \) ;

ImportDeclaration:
     import ImportList ;

ImportList:
     Import , ImportList
     Import ImportBindListOpt
     Import

Import:
     Identifier = ModuleName
     ModuleName

ImportBindListOpt:
     : ImportBindList
     epsilon

ImportBindList:
     ImportBindList , ImportBind
     ImportBind

ImportBind:
     Identifier = Identifier
     Identifier

AttributeSpecifier:
     Attributes : DeclDefsOpt
     Attributes DeclarationBlock

Attributes:
     Attributes Attribute
     Attribute

Attribute:
     StorageClassAttribute
     ProtectionAttribute
     LinkageAttribute
     AlignAttribute
     Pragma

StorageClassAttribute:
     synchronized
     deprecated
     static
     final
     override
     abstract
     const
     auto
     scope

ProtectionAttribute:
     private
     package
     protected
     public
     export

LinkageAttribute:
     extern \( Identifier \)
     extern \( Identifier \+\+ \)
     extern

AlignAttribute:
     align \( Integer \)
     align

Pragma:
     pragma \( Identifier , Expression \)
     pragma \( Identifier \)

FunctionBody:
     InStatement OutStatement BodyStatement
     OutStatement InStatement BodyStatement
     InStatement BodyStatement
     OutStatement BodyStatement
     BodyStatement

FunctionBodyOpt:
     FunctionBody
     ;

InStatement:
     in BlockStatement

OutStatement:
     out \( Identifier \) BlockStatement
     out BlockStatement

BodyStatement:
     body BlockStatement
     BlockStatement

ClassDeclaration:
     class Identifier BaseClassListOpt ClassBody

BaseClassListOpt:
     : BaseClassList
     epsilon

BaseClassList:
     BaseClassList , SuperClass
     SuperClass

SuperClass:
     ProtectionNT IdentifierList
     IdentifierList

ProtectionNT:
     private
     package
     public
     export

ClassBody:
     \{ \}
     \{ ClassBodyDeclarations \}

ClassBodyDeclarations:
     ClassBodyDeclarations ClassBodyDeclaration
     ClassBodyDeclaration

ClassBodyDeclaration:
     DeclDef
     ClassAllocator
     ClassDeallocator

Constructor:
     this Parameters FunctionBodyOpt

Destructor:
     ~ this \( \) FunctionBodyOpt

StaticConstructor:
     static this \( \) FunctionBody

StaticDestructor:
     static ~ this \( \) FunctionBody

Invariant:
     invariant BlockStatement
     invariant \( \) BlockStatement

UnitTest:
     unittest FunctionBody

ClassAllocator:
     new Parameters FunctionBody

ClassDeallocator:
     delete Parameters FunctionBody

InterfaceDeclaration:
     interface Identifier SuperInterfaceListOpt InterfaceBody

SuperInterfaceListOpt:
     : SuperInterfaces
     epsilon

SuperInterfaces:
     SuperInterfaces , SuperInterface
     SuperInterface

SuperInterface:
     ProtectionNT IdentifierList
     IdentifierList

InterfaceBody:
     \{ DeclDefsOpt \}

AggregateDeclaration:
     Tag IdentifierOpt StructBody
     Tag IdentifierOpt ;

Tag:
     struct
     union

StructBody:
     \{ \}
     \{ \} ;
     \{ StructBodyDeclarations \}
     \{ StructBodyDeclarations \} ;

StructBodyDeclarations:
     StructBodyDeclarations StructBodyDeclaration
     StructBodyDeclaration

StructBodyDeclaration:
     DeclDef
     StructAllocator
     StructDeallocator

StructAllocator:
     ClassAllocator

StructDeallocator:
     ClassDeallocator

ConditionalStatement:
     Condition Statement else Statement
     Condition Statement

Statement:
     NonEmptyStatement
     BlockStatement

StatementList:
     StatementList Statement
     Statement

NoScopeNonEmptyStatement:
     NonEmptyStatement
     BlockStatement

NoScopeStatement:
     NonEmptyStatement
     BlockStatement

NonEmptyStatement:
     DeclDefNoConditional
     NonEmptyNoDeclStatement

NonEmptyNoDeclStatement:
     LabeledStatement
     ExpressionStatement
     IfStatement
     ConditionalStatement
     WhileStatement
     DoStatement
     ForStatement
     ForeachStatement
     ForeachRangeStatement
     SwitchStatement
     CaseStatement
     DefaultStatement
     ContinueStatement
     BreakStatement
     ReturnStatement
     GotoStatement
     WithStatement
     SynchronizedStatement
     TryStatement
     ScopeGuardStatement
     ThrowStatement
     VolatileStatement
     AsmStatement
     PragmaStatement

ScopeStatement:
     NonEmptyStatement
     BlockStatement

NoDeclScopeStatement:
     NonEmptyNoDeclStatement
     BlockStatement

LabeledStatement:
     Identifier : NoScopeStatement

BlockStatement:
     \{ \}
     \{ StatementList \}

ExpressionStatement:
     Expression ;

IfStatement:
     if \( IfCondition \) ScopeStatement
     if \( IfCondition \) ScopeStatement else ScopeStatement

IfCondition:
     Expression
     auto Identifier = Expression
     BasicType Declarator = Expression

WhileStatement:
     while \( Expression \) ScopeStatement

DoStatement:
     do ScopeStatement while \( Expression \)

ForStatement:
     for \( NoScopeNonEmptyStatement ExpressionOpt ; ExpressionOpt \) ScopeStatement

ForeachStatement:
     Foreach \( ForeachTypeList ; Expression \) ScopeStatement

Foreach:
     foreach
     foreach_reverse

ForeachTypeList:
     ForeachTypeList , ForeachType
     ForeachType

ForeachType:
     inout TypeNT Identifier
     ref TypeNT Identifier
     TypeNT Identifier
     inout Identifier
     ref Identifier
     Identifier

ForeachRangeStatement:
     Foreach \( ForeachType ; AssignExpression \.\. AssignExpression \) ScopeStatement

SwitchStatement:
     switch \( Expression \) BlockStatement

CaseStatement:
     case Expression :

DefaultStatement:
     default :

ContinueStatement:
     continue ;
     continue Identifier ;

BreakStatement:
     break ;
     break Identifier ;

ReturnStatement:
     return ;
     return Expression ;

GotoStatement:
     goto Identifier ;
     goto default ;
     goto case ;
     goto case Expression ;

WithStatement:
     with \( Expression \) ScopeStatement
     with \( TemplateInstance \) ScopeStatement

SynchronizedStatement:
     synchronized NoDeclScopeStatement
     synchronized \( Expression \) ScopeStatement

TryStatement:
     try ScopeStatement Catches
     try ScopeStatement Catches FinallyStatement
     try ScopeStatement FinallyStatement

Catches:
     LastCatch
     Catch Catches
     Catch

LastCatch:
     catch NoScopeNonEmptyStatement

Catch:
     catch \( Parameter \) NoScopeNonEmptyStatement

FinallyStatement:
     finally NoScopeNonEmptyStatement

ThrowStatement:
     throw Expression ;

ScopeGuardStatement:
     scope \( Identifier \) Statement

VolatileStatement:
     volatile Statement
     volatile ;

AsmStatement:
     asm \{ \}
     asm \{ AsmInstructionList \}

AsmInstructionList:
     AsmInstructionList AsmInstruction
     AsmInstruction

AsmInstruction:
    [ for !\<= private lazy \<\>= r"[^"]*"[cdw]? in class typeof \^= \< override double __VENDOR__ [1-9][0-9_]*(L|[uU]|L[uU]|[uU]L)? [0-9][0-9_]*\.?([fFLi]|[fFL]i) \> with uint \? goto is cdouble alias function 0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)(L|[uU]|L[uU]|[uU]L)? \*= __FILE__ q" switch asm dchar foreach idouble \<= static struct !\< import true \.\.\. !\> !\>= auto creal \\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})) foreach_reverse __TIMESTAMP__ export \+= !\<\> debug "(([^"\\]*(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))?)*)"[cdw]? float \<\< ~ break (([0-9_]*\.[0-9][0-9_]*([eE][\+\-]?[0-9][0-9_]*)?)|([0-9][0-9_]*[eE][\+\-]?[0-9][0-9_]*))([fFLi]|[fFL]i)? \<\> ! typeid char __TIME__ module real \[ != \>\>\> % 0[xX][0-9a-fA-F_]*\.?[0-9a-fA-F_]+[pP][\+\-]?[0-9_]+([fFLi]|[fFL]i)? \] & \^ unittest \>= \-\- const , \|= `[^`]*`[cdw]? \>\>= do / enum \-= false __LINE__ __VERSION__ case short scope this package finally == void interface !\<\>= pragma : (0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)|([1-9][0-9_]*))[fFL]?i ; '(([^'\\]|(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))))' x"[0-9a-fA-F_\n\r\t ]*"[cdw]? extern ubyte = protected int super q\{ typedef \.\. cast else null && ulong ref \| \>\>\>= align version [0-9][0-9_]*\.>[^\.] mixin body synchronized abstract \|\| __DATE__ volatile final [a-zA-Z_][_a-zA-Z0-9]* \<\<= \>\> \$ inout !is>[^_a-zA-Z0-9] %= delete continue template \( union ifloat \) byte \* delegate try \+ catch ireal deprecated bool invariant new \- throw \. \+\+ default return ushort ~= public out cfloat long &= if /= while __traits assert wchar]

PragmaStatement:
     Pragma NoScopeStatement

DeclarationBlock:
     \{ DeclDefsOpt \}
     DeclDef

MixinDeclaration:
     mixin \( Expression \) ;

Declaration:
     TypedefAlias Declaration2
     TypedefAlias Attributes Declaration2
     TypedefAlias Attributes Identifier = AssignExpression ;
     Attributes Declaration2
     Attributes IdentifierSimpleInitializerList ;
     Declaration2

TypedefAlias:
     typedef
     alias

Declaration2:
     BasicType Declarator FunctionBody
     BasicType Declarators ;

IdentifierSimpleInitializerList:
     IdentifierSimpleInitializerList , Identifier = AssignExpression
     Identifier = AssignExpression

Declarators:
     DeclaratorInitializer
     DeclaratorInitializer , IdentifierInitializerList

DeclaratorInitializer:
     Declarator
     Declarator = Initializer

IdentifierInitializerList:
     IdentifierInitializerList , IdentifierInitializer
     IdentifierInitializer

IdentifierInitializer:
     Identifier
     Identifier = Initializer

BasicType:
     BasicTypeNoIdList
     \. IdentifierList
     IdentifierList

BasicTypeNoIdList:
     bool
     byte
     ubyte
     short
     ushort
     int
     uint
     long
     ulong
     char
     wchar
     dchar
     float
     double
     real
     ifloat
     idouble
     ireal
     cfloat
     cdouble
     creal
     void
     Typeof
     Typeof IdentifierList
     TypeConstructor \( TypeNT \)

BasicType2:
     \*
     \[ \]
     \[ Expression \]
     \[ TypeNT \]
     \[ AssignExpression \.\. AssignExpression \]
     delegate Parameters
     function Parameters

TypeConstructor:
     const
     invariant

Declarator:
     BasicType2 DeclaratorOpt
     Identifier DeclaratorSuffixesOpt
     \( Declarator \) DeclaratorSuffixesOpt

DeclaratorOpt:
     Declarator
     epsilon

DeclaratorSuffixesOpt:
     DeclaratorSuffixesOpt DeclaratorSuffix
     epsilon

DeclaratorSuffix:
     \[ \]
     \[ Expression \]
     \[ TypeNT \]
     Parameters

IdentifierList:
     Identifier
     IdentifierList \. Identifier
     TemplateInstance
     IdentifierList \. TemplateInstance

Typeof:
     typeof \( Expression \)

TypeNT:
     BasicType
     BasicType Declarator2

TypeOpt:
     TypeNT
     epsilon

Declarator2:
     BasicType2
     BasicType2 Declarator2
     \( Declarator2 \) DeclaratorSuffixesOpt

Parameters:
     \( \)
     \( ParameterList \)

ParameterListOpt:
     ParameterList
     epsilon

ParameterList:
     Parameter
     Parameter , ParameterList
     Parameter \.\.\.
     \.\.\.

Parameter:
     Parameter2
     InOut Parameter2
     ParameterStorageClasses Parameter2
     InOut ParameterStorageClasses Parameter2

Parameter2:
     BasicType DeclaratorOpt
     BasicType DeclaratorOpt = AssignExpression

ParameterStorageClasses:
     ParameterStorageClasses ParameterStorageClass
     ParameterStorageClass

ParameterStorageClass:
     const
     invariant
     final
     scope
     static

InOut:
     inout
     in
     out
     ref
     lazy

Initializer:
     void
     NonVoidInitializer

NonVoidInitializer:
     AssignExpression
     ArrayInitializer
     StructInitializer

ArrayInitializer:
     \[ \]
     \[ ArrayStructMemberInitializers \]

StructInitializer:
     \{ \}
     \{ ArrayStructMemberInitializers \}

ArrayStructMemberInitializers:
     ArrayStructMemberInitializers , ArrayStructMemberInitializer
     ArrayStructMemberInitializers ,
     ArrayStructMemberInitializer

ArrayStructMemberInitializer:
     NonVoidInitializer
     Identifier : NonVoidInitializer

EnumDeclaration:
     enum Identifier EnumBaseTypeOpt EnumBody
     enum EnumBaseTypeOpt EnumBody

EnumBaseTypeOpt:
     : TypeNT
     epsilon

EnumBody:
     ;
     \{ EnumMembers \}

EnumMembers:
     EnumMembers , EnumMember
     EnumMembers ,
     EnumMember

EnumMember:
     Identifier EnumInitializerOpt

EnumInitializerOpt:
     = AssignExpression
     epsilon

TemplateDeclaration:
     template Identifier \( TemplateParameterListOpt \) \{ DeclDefsOpt \}

TemplateParameterListOpt:
     TemplateParameterList
     epsilon

TemplateParameterList:
     TemplateParameterList , TemplateParameter
     TemplateParameter

TemplateParameter:
     TemplateAliasParameter
     TemplateTupleParameter
     TemplateValueParameter
     TemplateTypeParameter

TemplateTypeParameter:
     Identifier TemplateTypeParameterSpecializationOpt TemplateTypeParameterDefaultOpt

TemplateTypeParameterSpecializationOpt:
     : TypeNT
     epsilon

TemplateTypeParameterDefaultOpt:
     = TypeNT
     epsilon

TemplateValueParameter:
     BasicType Declarator TemplateValueParameterSpecializationOpt TemplateValueParameterDefaultOpt

TemplateValueParameterSpecializationOpt:
     : ConditionalExpression
     epsilon

TemplateValueParameterDefaultOpt:
     = ConditionalExpression
     epsilon

TemplateAliasParameter:
     alias Identifier TemplateAliasParameterSpecializationOpt TemplateAliasParameterDefaultOpt

TemplateAliasParameterSpecializationOpt:
     : TypeNT
     epsilon

TemplateAliasParameterDefaultOpt:
     = TypeNT
     epsilon

TemplateTupleParameter:
     Identifier \.\.\.

ClassTemplateDeclaration:
     class Identifier \( TemplateParameterListOpt \) BaseClassListOpt ClassBody

InterfaceTemplateDeclaration:
     interface Identifier \( TemplateParameterListOpt \) SuperInterfaceListOpt InterfaceBody

StructTemplateDeclaration:
     struct Identifier \( TemplateParameterListOpt \) StructBody

FunctionTemplateDeclaration:
     TypeIdent \( TemplateParameterList \) \( ParameterListOpt \) FunctionBody

TypeIdent:
     BasicType Identifier
     TypeNT Identifier

TemplateInstance:
     Identifier ! \( TemplateArgumentListOpt \)

TemplateArgumentListOpt:
     TemplateArgumentList
     epsilon

TemplateArgumentList:
     TemplateArgumentList , TemplateArgument
     TemplateArgument

TemplateArgument:
     TypeNT
     AssignExpression
     Identifier

TemplateMixin:
     mixin Identifier TemplateMixin2 IdentifierOpt ;

TemplateMixin2:
     ! \( TemplateArgumentListOpt \)
     epsilon

Expression:
     Expression , AssignExpression
     AssignExpression

ExpressionOpt:
     Expression
     epsilon

AssignExpression:
     ConditionalExpression
     ConditionalExpression = AssignExpression
     ConditionalExpression \+= AssignExpression
     ConditionalExpression \-= AssignExpression
     ConditionalExpression \*= AssignExpression
     ConditionalExpression /= AssignExpression
     ConditionalExpression %= AssignExpression
     ConditionalExpression &= AssignExpression
     ConditionalExpression \|= AssignExpression
     ConditionalExpression \^= AssignExpression
     ConditionalExpression ~= AssignExpression
     ConditionalExpression \<\<= AssignExpression
     ConditionalExpression \>\>= AssignExpression
     ConditionalExpression \>\>\>= AssignExpression

ConditionalExpression:
     OrOrExpression
     OrOrExpression \? Expression : ConditionalExpression

OrOrExpression:
     AndAndExpression
     OrOrExpression \|\| AndAndExpression

AndAndExpression:
     OrExpression
     AndAndExpression && OrExpression

OrExpression:
     XorExpression
     OrExpression \| XorExpression

XorExpression:
     AndExpression
     XorExpression \^ AndExpression

AndExpression:
     CmpExpression
     AndExpression & CmpExpression

CmpExpression:
     ShiftExpression
     ShiftExpression == ShiftExpression
     ShiftExpression != ShiftExpression
     ShiftExpression is ShiftExpression
     ShiftExpression NotIs ShiftExpression
     ShiftExpression \< ShiftExpression
     ShiftExpression \<= ShiftExpression
     ShiftExpression \> ShiftExpression
     ShiftExpression \>= ShiftExpression
     ShiftExpression !\<\>= ShiftExpression
     ShiftExpression !\<\> ShiftExpression
     ShiftExpression \<\> ShiftExpression
     ShiftExpression \<\>= ShiftExpression
     ShiftExpression !\> ShiftExpression
     ShiftExpression !\>= ShiftExpression
     ShiftExpression !\< ShiftExpression
     ShiftExpression !\<= ShiftExpression
     ShiftExpression in ShiftExpression

NotIs:
     !is>[^_a-zA-Z0-9]

IsNotIs:
     is
     !is>[^_a-zA-Z0-9]

ShiftExpression:
     AddExpression
     ShiftExpression \<\< AddExpression
     ShiftExpression \>\> AddExpression
     ShiftExpression \>\>\> AddExpression

AddExpression:
     MulExpression
     AddExpression \+ MulExpression
     AddExpression \- MulExpression
     CatExpression

CatExpression:
     AddExpression ~ MulExpression

MulExpression:
     UnaryExpression
     MulExpression \* UnaryExpression
     MulExpression / UnaryExpression
     MulExpression % UnaryExpression

UnaryExpression:
     PostfixExpression
     & UnaryExpression
     \+\+ UnaryExpression
     \-\- UnaryExpression
     \* UnaryExpression
     \- UnaryExpression
     \+ UnaryExpression
     ! UnaryExpression
     ~ UnaryExpression
     \( TypeNT \) \. Identifier
     NewExpression
     delete UnaryExpression
     cast \( TypeNT \) UnaryExpression

PostfixExpression:
     Integer
     Float
     \$
     null
     true
     false
     AssertExpression
     MixinExpression
     IsExpression
     PostfixExpression2

PostfixExpression2:
     PrimaryExpression
     PostfixExpression2 \. Identifier
     PostfixExpression2 \. TemplateInstance
     PostfixExpression2 \+\+
     PostfixExpression2 \-\-
     PostfixExpression2 \( ArgumentList \)
     PostfixExpression2 \[ ArgumentList \]
     PostfixExpression2 \[ AssignExpression \.\. AssignExpression \]

PrimaryExpression:
     Identifier
     \. Identifier
     TemplateInstance
     \. TemplateInstance
     this
     super
     CharacterLiteral
     StringLiterals
     ArrayLiteral
     AssocArrayLiteral
     FunctionLiteral
     ImportExpression
     BasicTypeNoIdList \. Identifier
     typeid \( TypeNT \)
     \( Expression \)
     TraitsExpression

AssertExpression:
     assert \( AssignExpression \)
     assert \( AssignExpression , AssignExpression \)

MixinExpression:
     mixin \( AssignExpression \)

ImportExpression:
     import \( AssignExpression \)

IsExpression:
     IsNotIs \( TypeNT \)
     IsNotIs \( TypeNT : TypeSpecialization \)
     IsNotIs \( TypeNT == TypeSpecialization \)
     IsNotIs \( TypeNT Identifier \)
     IsNotIs \( TypeNT Identifier : TypeSpecialization \)
     IsNotIs \( TypeNT Identifier == TypeSpecialization \)
     IsNotIs \( TypeNT Identifier : TypeSpecialization , TemplateParameterList \)
     IsNotIs \( TypeNT Identifier == TypeSpecialization , TemplateParameterList \)

TypeSpecialization:
     TypeNT
     typedef
     struct
     union
     class
     interface
     enum
     function
     delegate
     super
     return

StringLiterals:
     StringLiteral
     StringLiterals StringLiteral

ArrayLiteral:
     \[ ArgumentList \]

AssocArrayLiteral:
     \[ KeyValuePairs \]

KeyValuePairs:
     KeyValuePair
     KeyValuePair , KeyValuePairs

KeyValuePair:
     ConditionalExpression : ConditionalExpression

FunctionLiteral:
     function TypeOpt \( ParameterListOpt \) FunctionBody
     delegate TypeOpt \( ParameterListOpt \) FunctionBody
     function TypeOpt FunctionBody
     delegate TypeOpt FunctionBody
     \( ParameterListOpt \) FunctionBody
     FunctionBody

NewExpression:
     NewArguments TypeNT \[ AssignExpression \]
     NewArguments TypeNT \( ArgumentList \)
     NewArguments TypeNT
     NewArguments ClassArguments BaseClassListOpt \{ DeclDefsOpt \}

NewArguments:
     new \( ArgumentList \)
     new

ClassArguments:
     class \( ArgumentList \)
     class

ArgumentList:
     Expression
     epsilon

TraitsExpression:
     __traits \( Identifier , TraitsArguments \)

TraitsArguments:
     TraitsArguments , TraitsArgument
     TraitsArgument

TraitsArgument:
     AssignExpression
     TypeNT

CharacterLiteral:
     '(([^'\\]|(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))))'

StringLiteral:
     "(([^"\\]*(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))?)*)"[cdw]?
     r"[^"]*"[cdw]?
     `[^`]*`[cdw]?
     x"[0-9a-fA-F_\n\r\t ]*"[cdw]?
     \\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8}))
     q"
     q\{ Tokens \}
     __FILE__
     __DATE__
     __TIME__
     __TIMESTAMP__
     __VENDOR__

Tokens:
     Tokens Token
     Token

Token:
    [ for !\<= private lazy \<\>= r"[^"]*"[cdw]? in class typeof \^= \< override double __VENDOR__ [1-9][0-9_]*(L|[uU]|L[uU]|[uU]L)? [0-9][0-9_]*\.?([fFLi]|[fFL]i) \> with uint \? goto is cdouble alias function 0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)(L|[uU]|L[uU]|[uU]L)? \*= __FILE__ q" switch asm dchar foreach idouble \<= static struct !\< import true \.\.\. !\> !\>= auto creal \\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})) foreach_reverse __TIMESTAMP__ export \+= !\<\> debug "(([^"\\]*(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))?)*)"[cdw]? float \<\< ~ break (([0-9_]*\.[0-9][0-9_]*([eE][\+\-]?[0-9][0-9_]*)?)|([0-9][0-9_]*[eE][\+\-]?[0-9][0-9_]*))([fFLi]|[fFL]i)? \<\> ! typeid char __TIME__ module real \[ != \>\>\> % 0[xX][0-9a-fA-F_]*\.?[0-9a-fA-F_]+[pP][\+\-]?[0-9_]+([fFLi]|[fFL]i)? \] & \^ unittest \>= \-\- const , \|= `[^`]*`[cdw]? \>\>= do / enum \-= false __LINE__ __VERSION__ case short scope this package finally == void interface !\<\>= pragma : (0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)|([1-9][0-9_]*))[fFL]?i ; '(([^'\\]|(\\(['"\?\\abfnrtv]|([0-7_]{1,3})|(x[0-9a-fA-F]{2})|(u[0-9a-fA-F]{4})|(U[0-9a-fA-F]{8})))))' x"[0-9a-fA-F_\n\r\t ]*"[cdw]? extern ubyte = protected int super q\{ typedef \.\. cast else null && ulong ref \| \>\>\>= align version [0-9][0-9_]*\.>[^\.] mixin body synchronized abstract \|\| __DATE__ volatile final [a-zA-Z_][_a-zA-Z0-9]* \<\<= \>\> \$ inout !is>[^_a-zA-Z0-9] %= delete continue template \( union ifloat \) byte \* delegate try \+ catch ireal deprecated bool invariant new \- throw \. \+\+ default return ushort ~= public out cfloat long &= if /= while __traits assert wchar]
     \{ Tokens \}

Integer:
     0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)(L|[uU]|L[uU]|[uU]L)?
     [1-9][0-9_]*(L|[uU]|L[uU]|[uU]L)?
     __LINE__
     __VERSION__

Float:
     (([0-9_]*\.[0-9][0-9_]*([eE][\+\-]?[0-9][0-9_]*)?)|([0-9][0-9_]*[eE][\+\-]?[0-9][0-9_]*))([fFLi]|[fFL]i)?
     [0-9][0-9_]*\.?([fFLi]|[fFL]i)
     [0-9][0-9_]*\.>[^\.]
     0[xX][0-9a-fA-F_]*\.?[0-9a-fA-F_]+[pP][\+\-]?[0-9_]+([fFLi]|[fFL]i)?
     (0([xX][0-9a-fA-F_]*|[bB][01_]*|[0-7_]*)|([1-9][0-9_]*))[fFL]?i

Identifier:
     [a-zA-Z_][_a-zA-Z0-9]*

IdentifierOpt:
     Identifier
     epsilon